Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: ArtemisRegistryHttpClient extends ArtemisHttpClient { public void register(final Set<Instance> instances) { try { Preconditions.checkArgument(!CollectionUtils.isEmpty(instances), "instances"); final RegisterRequest request = new RegisterRequest(Lists.newArrayList(instances)); final RegisterResponse response = this.request(RestPaths.REGISTRY_REGISTER_FULL_PATH, request, RegisterResponse.class); if (ResponseStatusUtil.isFail(response.getResponseStatus())) { _logger.error("register instances failed. Response:" + JacksonJsonSerializer.INSTANCE.serialize(response)); } else if (ResponseStatusUtil.isPartialFail(response.getResponseStatus())) { _logger.warn("register instances patial failed. Response:" + JacksonJsonSerializer.INSTANCE.serialize(response)); } logEvent(response.getResponseStatus(), "registry", "register"); } catch (final Throwable e) { _logger.warn("register instances failed", e); logEvent("registry", "register"); } } ArtemisRegistryHttpClient(final ArtemisClientConfig config); void register(final Set<Instance> instances); void unregister(final Set<Instance> instances); }### Answer: @Test public void testRegister() throws Exception { client.register(Instances.newInstances(3)); }
### Question: ArtemisRegistryHttpClient extends ArtemisHttpClient { public void unregister(final Set<Instance> instances) { try { Preconditions.checkArgument(!CollectionUtils.isEmpty(instances), "instances"); final UnregisterRequest request = new UnregisterRequest(Lists.newArrayList(instances)); final UnregisterResponse response = this.request(RestPaths.REGISTRY_UNREGISTER_FULL_PATH, request, UnregisterResponse.class); if (ResponseStatusUtil.isFail(response.getResponseStatus())) { _logger.error("unregister instances failed. Response:" + JacksonJsonSerializer.INSTANCE.serialize(response)); } else if (ResponseStatusUtil.isPartialFail(response.getResponseStatus())) { _logger.warn("unregister instances patial failed. Response:" + JacksonJsonSerializer.INSTANCE.serialize(response)); } logEvent(response.getResponseStatus(), "registry", "unregister"); } catch (final Throwable e) { _logger.warn("unregister instances failed", e); logEvent("registry", "unregister"); } } ArtemisRegistryHttpClient(final ArtemisClientConfig config); void register(final Set<Instance> instances); void unregister(final Set<Instance> instances); }### Answer: @Test public void testUnregister() throws Exception { client.unregister(Instances.newInstances(3)); }
### Question: InstanceRepository { public void register(final Set<Instance> instances) { if (CollectionUtils.isEmpty(instances)) { return; } _client.unregister(instances); updateInstances(instances, RegisterType.register); } InstanceRepository(final ArtemisClientConfig config); Set<Instance> getAvailableInstances(); TextMessage getHeartbeatMessage(); void registerToRemote(final Set<Instance> instances); void register(final Set<Instance> instances); void unregister(final Set<Instance> instances); }### Answer: @Test public void testRegister() { final Set<Instance> instances = Instances.newInstances(2); repository.register(instances); Assert.assertTrue(_instances.get().containsAll(instances)); } @Test public void registerToServicesRegistry() throws InterruptedException { final Set<Instance> instances = Instances.newInstances(2); repository.register(instances); Assert.assertTrue(_instances.get().containsAll(instances)); }
### Question: InstanceRepository { public void unregister(final Set<Instance> instances) { if (CollectionUtils.isEmpty(instances)) { return; } _client.unregister(instances); updateInstances(instances, RegisterType.unregister); } InstanceRepository(final ArtemisClientConfig config); Set<Instance> getAvailableInstances(); TextMessage getHeartbeatMessage(); void registerToRemote(final Set<Instance> instances); void register(final Set<Instance> instances); void unregister(final Set<Instance> instances); }### Answer: @Test public void testUnregister() { final Set<Instance> instances = Instances.newInstances(2); repository.register(instances); Assert.assertTrue(_instances.get().containsAll(instances)); repository.unregister(instances); for (final Instance instance : instances) { Assert.assertFalse(_instances.get().contains(instance)); } }
### Question: AddressManager { public AddressContext getContext() { AddressContext context = _addressContext.get(); if (!context.isAavailable() \|\| context.isExpired()) { context = newAddressContext(); _addressContext.set(context); } return context; } AddressManager(final ArtemisClientManagerConfig managerConfig, final AddressRepository addressRepository); AddressContext getContext(); static AddressManager getDiscoveryAddressManager(final String clientId, final ArtemisClientManagerConfig managerConfig); static AddressManager getRegistryAddressManager(final String clientId, final ArtemisClientManagerConfig managerConfig); }### Answer: @Test public void testMarkUnavailable() throws InterruptedException, ExecutionException, TimeoutException{ final AddressContext context = addr.getContext(); Assert.assertTrue(context.isAavailable()); context.markUnavailable(); Assert.assertFalse(context.isAavailable()); final AddressContext newContext = addr.getContext(); Assert.assertFalse(context == newContext); Assert.assertNotNull(newContext.getHttpUrl()); }
### Question: AddressContext { public String getHttpUrl() { return _httpUrl; } AddressContext(final String clientId, final ArtemisClientManagerConfig managerConfig); AddressContext(final String clientId, final ArtemisClientManagerConfig managerConfig, final String httpUrl, final String wsEndpointSuffix); String getHttpUrl(); String customHttpUrl(final String path); String getWebSocketEndPoint(); boolean isAavailable(); boolean isExpired(); void markUnavailable(); }### Answer: @Test public void testGetHttpUrl() { final AddressContext context = newAddressContext("http: Assert.assertEquals("http: Assert.assertEquals("http: }
### Question: ServiceContext { public synchronized boolean deleteInstance(Instance instance) { if (instance == null) return false; List<Instance> instances = service.getInstances(); if (instances == null) return false; return instances.remove(instance); } ServiceContext(DiscoveryConfig discoveryConfig); DiscoveryConfig getDiscoveryConfig(); synchronized Service newService(); synchronized void setService(Service service); synchronized boolean deleteInstance(Instance instance); synchronized boolean updateInstance(Instance instance); synchronized boolean addInstance(Instance instance); synchronized boolean isAvailable(); synchronized Set<ServiceChangeListener> getListeners(); synchronized void addListener(final ServiceChangeListener listener); ServiceChangeEvent newServiceChangeEvent(final String changeType); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object other); }### Answer: @Test public void testDeleteInstance() { ServiceContext context = new ServiceContext(_discoveryConfig); Instance instance1 = Instances.newInstance(_serviceId); Assert.assertTrue(context.addInstance(instance1)); Assert.assertEquals(1, context.newService().getInstances().size()); Assert.assertTrue(context.deleteInstance(instance1)); Assert.assertEquals(0, context.newService().getInstances().size()); Assert.assertFalse(context.deleteInstance(instance1)); }
### Question: AddressContext { public String getWebSocketEndPoint() { return _webSocketEndpoint; } AddressContext(final String clientId, final ArtemisClientManagerConfig managerConfig); AddressContext(final String clientId, final ArtemisClientManagerConfig managerConfig, final String httpUrl, final String wsEndpointSuffix); String getHttpUrl(); String customHttpUrl(final String path); String getWebSocketEndPoint(); boolean isAavailable(); boolean isExpired(); void markUnavailable(); }### Answer: @Test public void testGetWebSocketEndPoint() { final AddressContext context = newAddressContext("http: Assert.assertEquals("ws: }
### Question: AddressContext { public boolean isExpired() { return System.currentTimeMillis() >= (_ttl.typedValue() + _createTime); } AddressContext(final String clientId, final ArtemisClientManagerConfig managerConfig); AddressContext(final String clientId, final ArtemisClientManagerConfig managerConfig, final String httpUrl, final String wsEndpointSuffix); String getHttpUrl(); String customHttpUrl(final String path); String getWebSocketEndPoint(); boolean isAavailable(); boolean isExpired(); void markUnavailable(); }### Answer: @Test public void testIsRetired() { final AddressContext context = newAddressContext("http: Assert.assertFalse(context.isExpired()); }
### Question: AddressRepository { protected void refresh() { try { _logger.info("start refresh service urls"); String domainUrl = _domainUrl.typedValue(); if (StringValues.isNullOrWhitespace(domainUrl)) { _logger.error("domain url should not be null or empty for artemis client"); return; } final List<String> urls = getUrlsFromService(domainUrl); if (!CollectionUtils.isEmpty(urls)) { _avlSvcUrls.set(urls); } } catch (final Throwable e) { _logger.warn("refesh service urls failed", e); } finally { _logger.info("end refresh service urls"); } } AddressRepository(final String clientId, final ArtemisClientManagerConfig managerConfig, final String path); String get(); }### Answer: @Test public void testRefresh() { _addressRepository.refresh(); Assert.assertNotNull(_addressRepository.get()); }
### Question: Conditions { public static boolean verifyInstance(final Instance instance) { return (instance != null) && !StringValues.isNullOrWhitespace(instance.getInstanceId()) && !StringValues.isNullOrWhitespace(instance.getServiceId()) && !StringValues.isNullOrWhitespace(instance.getUrl()); } static boolean verifyInstance(final Instance instance); static boolean verifyInstances(final Instance[] instances); static boolean verifyInstances(final Collection<Instance> instances); static boolean verifyService(final Service service); static boolean verifyServices(final Collection<Service> services); }### Answer: @Test public void verifyInstance() { { Assert.assertFalse(Conditions.verifyInstance(new Instance())); } { Assert.assertTrue(Conditions.verifyInstance(Instances.newInstance())); } }
### Question: Conditions { public static boolean verifyInstances(final Instance[] instances) { if ((instances == null) \|\| (instances.length == 0)) { return false; } for (final Instance instance : instances) { if (!verifyInstance(instance)) { return false; } } return true; } static boolean verifyInstance(final Instance instance); static boolean verifyInstances(final Instance[] instances); static boolean verifyInstances(final Collection<Instance> instances); static boolean verifyService(final Service service); static boolean verifyServices(final Collection<Service> services); }### Answer: @Test public void verifyInstances() { { final Instance[] instances = new Instance[]{Instances.newInstance(), new Instance()}; Assert.assertFalse(Conditions.verifyInstances(instances)); Assert.assertFalse(Conditions.verifyInstances(Lists.newArrayList(instances))); } { final Instance[] instances = new Instance[]{Instances.newInstance()}; Assert.assertTrue(Conditions.verifyInstances(instances)); Assert.assertTrue(Conditions.verifyInstances(Lists.newArrayList(instances))); } }
### Question: Conditions { public static boolean verifyService(final Service service) { return (service != null) && !StringValues.isNullOrWhitespace(service.getServiceId()); } static boolean verifyInstance(final Instance instance); static boolean verifyInstances(final Instance[] instances); static boolean verifyInstances(final Collection<Instance> instances); static boolean verifyService(final Service service); static boolean verifyServices(final Collection<Service> services); }### Answer: @Test public void verifyService() { { Assert.assertFalse(Conditions.verifyService(new Service())); } { Assert.assertTrue(Conditions.verifyService(new Service(Services.newServiceId()))); } }
### Question: Conditions { public static boolean verifyServices(final Collection<Service> services) { if (CollectionUtils.isEmpty(services)) { return false; } for (final Service service : services) { if (!verifyService(service)) { return false; } } return true; } static boolean verifyInstance(final Instance instance); static boolean verifyInstances(final Instance[] instances); static boolean verifyInstances(final Collection<Instance> instances); static boolean verifyService(final Service service); static boolean verifyServices(final Collection<Service> services); }### Answer: @Test public void verifyServices() { { Assert.assertFalse(Conditions.verifyServices(Lists.newArrayList(new Service(), new Service(Services.newServiceId())))); } { Assert.assertTrue(Conditions.verifyServices(Lists.newArrayList(new Service(Services.newServiceId()), new Service(Services.newServiceId())))); } }
### Question: WebSocketSessionContext { protected void connect() { if (_isConnecting.compareAndSet(false, true)) { try { if (rateLimiter.isRateLimited("connect")) { _logger.error("WebSocketSessionContext reconnect times exceed expected value for a period time"); return; } final AddressContext context = _addressManager.getContext(); if (!context.isAavailable()) { return; } ListenableFuture<WebSocketSession> future = _wsClient.doHandshake(_handler, context.getWebSocketEndPoint()); future.addCallback(new WebSocketSessionCallback(this, context)); try { WebSocketSession session = future.get(_connectTimeout.typedValue(), TimeUnit.MILLISECONDS); final WebSocketSession oldSession = _session.getAndSet(session); _lastUpdatedTime = System.currentTimeMillis(); _addressContext.set(context); disconnect(oldSession); WebSocketSessionContext.this.afterConnectionEstablished(session); _logger.info("WebSocketSessionContext connected to: " + context.getWebSocketEndPoint()); } catch (Throwable ex) { context.markUnavailable(); _logger.warn("get WebSocketSession failed within the time specified", ex); } } catch (final Throwable e) { _addressContext.get().markUnavailable(); _logger.warn("connect to websocket endpoint failed", e); } finally { _isConnecting.set(false); } } } WebSocketSessionContext(final ArtemisClientConfig config); void start(); static void disconnect(final WebSocketSession session); WebSocketSession get(); void checkHealth(); void markdown(); void shutdown(); }### Answer: @Test(timeout=5000) public void testConnect() { final WebSocketSession session = registrySessionContext.get(); if (registrySessionContext.isAvailable()) { WebSocketSessionContext.disconnect(session); Assert.assertFalse(session.isOpen()); } Assert.assertTrue(registrySessionContext.isAvailable()); registrySessionContext.connect(); Assert.assertTrue(registrySessionContext.isAvailable()); }
### Question: WebSocketSessionContext { protected boolean isExpired() { return System.currentTimeMillis() >= (_lastUpdatedTime + _ttl.typedValue()); } WebSocketSessionContext(final ArtemisClientConfig config); void start(); static void disconnect(final WebSocketSession session); WebSocketSession get(); void checkHealth(); void markdown(); void shutdown(); }### Answer: @Test public void testIsExpired() { Assert.assertFalse(registrySessionContext.isExpired()); }
### Question: WebSocketSessionContext { public void checkHealth() { if (_isChecking.compareAndSet(false, true)) { try { boolean available = _addressContext.get().isAavailable() && !isExpired() && isAvailable(); if (!available) { connect(); } } catch (final Throwable e) { _logger.warn("WebSocketSession check health failed", e); } finally { _isChecking.set(false); } } } WebSocketSessionContext(final ArtemisClientConfig config); void start(); static void disconnect(final WebSocketSession session); WebSocketSession get(); void checkHealth(); void markdown(); void shutdown(); }### Answer: @Test public void testCheckHealth() { registrySessionIsExpired.set(true); registrySessionContext.checkHealth(); registrySessionIsExpired.set(false); }
### Question: ServiceContext { public synchronized boolean addInstance(Instance instance) { if (instance == null) { return false; } String instanceServiceId = instance.getServiceId(); if (instanceServiceId == null \|\| !serviceId.equals(instanceServiceId.toLowerCase())) { return false; } List<Instance> instances = service.getInstances(); if (instances == null) { instances = new ArrayList<>(); } deleteInstance(instance); instances.add(instance); service.setInstances(instances); return true; } ServiceContext(DiscoveryConfig discoveryConfig); DiscoveryConfig getDiscoveryConfig(); synchronized Service newService(); synchronized void setService(Service service); synchronized boolean deleteInstance(Instance instance); synchronized boolean updateInstance(Instance instance); synchronized boolean addInstance(Instance instance); synchronized boolean isAvailable(); synchronized Set<ServiceChangeListener> getListeners(); synchronized void addListener(final ServiceChangeListener listener); ServiceChangeEvent newServiceChangeEvent(final String changeType); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object other); }### Answer: @Test public void testAddInstance() { ServiceContext context = new ServiceContext(_discoveryConfig); Instance instance1 = Instances.newInstance(_serviceId); Assert.assertTrue(context.addInstance(instance1)); Assert.assertEquals(1, context.newService().getInstances().size()); Instance instance2 = instance1.clone(); instance2.setServiceId(instance1.getServiceId().toUpperCase()); Assert.assertTrue(context.addInstance(instance2)); Assert.assertEquals(1, context.newService().getInstances().size()); Assert.assertFalse(context.addInstance(Instances.newInstance())); Assert.assertEquals(1, context.newService().getInstances().size()); Assert.assertTrue(context.addInstance(Instances.newInstance(_serviceId))); Assert.assertEquals(2, context.newService().getInstances().size()); }
### Question: WebSocketSessionContext { public WebSocketSession get() { return _session.get(); } WebSocketSessionContext(final ArtemisClientConfig config); void start(); static void disconnect(final WebSocketSession session); WebSocketSession get(); void checkHealth(); void markdown(); void shutdown(); }### Answer: @Test public void testGet() { Assert.assertNotNull(registrySessionContext.get()); }
### Question: ServerLogDao { public void insert(final ServerLogModel... logs) { if ((logs == null) \|\| (logs.length == 0)) { return; } this.insert(Lists.newArrayList(logs)); } private ServerLogDao(); List<ServerOperationLog> select(ServerLogModel filter, Boolean complete); List<ServerOperationLog> query(final String condition, final List<String> args); void insert(final ServerLogModel... logs); void insert(final List<ServerLogModel> logs); static final ServerLogDao INSTANCE; }### Answer: @Test public void testInsert() { final ServerLogModel log1 = ServerLogModels.newServerLogModel(); final ServerLogModel log2 = ServerLogModels.newServerLogModel(); final List<ServerLogModel> logs = Lists.newArrayList(log1, log2); log1.setComplete(true); log2.setComplete(true); _serverLogDao.insert(log1, log2); for (final ServerLogModel log : logs) { final List<ServerOperationLog> logModels = query(log); Assert.assertEquals(1, logModels.size()); ServerLogModels.assertServerLog(log, logModels.get(0)); } log1.setComplete(false); log2.setComplete(false); _serverLogDao.insert(log1, log2); for (final ServerLogModel log : logs) { final List<ServerOperationLog> logModels = query(log); Assert.assertEquals(1, logModels.size()); ServerLogModels.assertServerLog(log, logModels.get(0)); } }
### Question: ServerDao { public void insert(final ServerModel... servers) { if ((servers == null) \|\| (servers.length == 0)) { return; } this.insert(Lists.newArrayList(servers)); } private ServerDao(); List<ServerModel> queryServer(final String regionId, final String serverId); List<ServerModel> queryServers(final String regionId); List<ServerModel> queryServers(); List<ServerModel> query(final String condition, final String... args); void delete(final Long... ids); void delete(final ServerModel... servers); void delete(final List<ServerModel> serverList); void destroyServers(final List<ServerKey> serverKeys); void insert(final ServerModel... servers); void insert(final List<ServerModel> serverList); static final ServerDao INSTANCE; }### Answer: @Test public void testInsert() { final ServerModel server1 = ServerModels.newServerModel(); final ServerModel server2 = ServerModels.newServerModel(); final List<ServerModel> servers = Lists.newArrayList(server1, server2); serverDao.insert(server1, server2); serverDao.insert(servers); for (final ServerModel server : servers) { final List<ServerModel> serverModels = query(server); Assert.assertTrue(serverModels.size() == 1); ServerModels.assertServer(server, serverModels.get(0)); server.setToken(ServerModels.newServerModel().getToken()); server.setOperatorId(ServerModels.newServerModel().getOperatorId()); } serverDao.insert(servers); for (final ServerModel server : servers) { final List<ServerModel> serverModels = query(server); Assert.assertTrue(serverModels.size() == 1); ServerModels.assertServer(server, serverModels.get(0)); } }
### Question: ServerDao { public void destroyServers(final List<ServerKey> serverKeys) { if (CollectionUtils.isEmpty(serverKeys)) { return; } DataConfig.jdbcTemplate().batchUpdate("delete from server where region_id=? and server_id=?", new BatchPreparedStatementSetter() { @Override public int getBatchSize() { return serverKeys.size(); } @Override public void setValues(final PreparedStatement ps, final int index) throws SQLException { ServerKey serverKey = serverKeys.get(index); ps.setString(1, serverKey.getRegionId()); ps.setString(2, serverKey.getServerId()); } }); } private ServerDao(); List<ServerModel> queryServer(final String regionId, final String serverId); List<ServerModel> queryServers(final String regionId); List<ServerModel> queryServers(); List<ServerModel> query(final String condition, final String... args); void delete(final Long... ids); void delete(final ServerModel... servers); void delete(final List<ServerModel> serverList); void destroyServers(final List<ServerKey> serverKeys); void insert(final ServerModel... servers); void insert(final List<ServerModel> serverList); static final ServerDao INSTANCE; }### Answer: @Test public void testDestroyServers() { final ServerModel server1 = ServerModels.newServerModel(); final ServerModel server2 = ServerModels.newServerModel(); serverDao.insert(server1, server2); Assert.assertTrue(query(server1).size() == 1); Assert.assertTrue(query(server2).size() == 1); List<ServerKey> serverKeys = Lists.newArrayList(new ServerKey(server1.getRegionId(), server1.getServerId()), new ServerKey(server2.getRegionId(), server2.getServerId())); serverDao.destroyServers(serverKeys); Assert.assertTrue(query(server1).size() == 0); Assert.assertTrue(query(server2).size() == 0); }
### Question: InstanceLogDao { public void insert(final InstanceLogModel... logs) { if ((logs == null) \|\| (logs.length == 0)) { return; } this.insert(Lists.newArrayList(logs)); } private InstanceLogDao(); List<InstanceOperationLog> select(InstanceLogModel filter, Boolean complete); List<InstanceOperationLog> query(final String condition, final List<String> args); void insert(final InstanceLogModel... logs); void insert(final List<InstanceLogModel> logs); static final InstanceLogDao INSTANCE; }### Answer: @Test public void testInsert() { final InstanceLogModel log1 = InstanceLogModels.newInstanceLogModel(); final InstanceLogModel log2 = InstanceLogModels.newInstanceLogModel(); log1.setComplete(true); log2.setComplete(true); final List<InstanceLogModel> logs = Lists.newArrayList(log1, log2); _instanceLogDao.insert(log1, log2); for (final InstanceLogModel log : logs) { final List<InstanceOperationLog> logModels = query(log); Assert.assertEquals(1, logModels.size()); InstanceLogModels.assertInstanceLog(log, logModels.get(0)); } log1.setComplete(false); log2.setComplete(false); _instanceLogDao.insert(log1, log2); for (final InstanceLogModel log : logs) { final List<InstanceOperationLog> logModels = query(log); Assert.assertEquals(1, logModels.size()); InstanceLogModels.assertInstanceLog(log, logModels.get(0)); } }
### Question: InstanceDao { public void insert(final InstanceModel... instances) { if ((instances == null) \|\| (instances.length == 0)) { return; } this.insert(Lists.newArrayList(instances)); } private InstanceDao(); List<InstanceModel> queryInstance(final String regionId, final String serviceId, final String instanceId); List<InstanceModel> queryInstances(final String regionId); List<InstanceModel> queryInstances(); List<InstanceModel> queryInstances(final String regionId, final List<String> serviceIds); List<InstanceModel> query(final String condition, final String... args); void delete(final Long... ids); void delete(final InstanceModel... instances); void delete(final List<InstanceModel> instances); void destroyServers(final List<ServerKey> serverKeys); void insert(final InstanceModel... instances); void insert(final List<InstanceModel> instances); static final InstanceDao INSTANCE; }### Answer: @Test public void testInsert() { final InstanceModel instance1 = InstanceModels.newInstanceModel(); final InstanceModel instance2 = InstanceModels.newInstanceModel(); final List<InstanceModel> instances = Lists.newArrayList(instance1, instance2); instanceDao.insert(instance1, instance2); instanceDao.insert(instances); for (final InstanceModel instance : instances) { final List<InstanceModel> instanceModels = query(instance); Assert.assertTrue(instanceModels.size() == 1); InstanceModels.assertInstance(instance, instanceModels.get(0)); instance.setOperatorId(InstanceModels.newInstanceModel().getOperatorId()); instance.setToken(InstanceModels.newInstanceModel().getToken()); } instanceDao.insert(instances); for (final InstanceModel instance : instances) { final List<InstanceModel> instanceModels = query(instance); Assert.assertTrue(instanceModels.size() == 1); InstanceModels.assertInstance(instance, instanceModels.get(0)); } }
### Question: InstanceDao { public void destroyServers(final List<ServerKey> serverKeys) { if (CollectionUtils.isEmpty(serverKeys)) { return; } DataConfig.jdbcTemplate().batchUpdate("delete from instance where region_id=? and instance_id=?", new BatchPreparedStatementSetter() { @Override public int getBatchSize() { return serverKeys.size(); } @Override public void setValues(final PreparedStatement ps, final int index) throws SQLException { ServerKey serverKey = serverKeys.get(index); ps.setString(1, serverKey.getRegionId()); ps.setString(2, serverKey.getServerId()); } }); } private InstanceDao(); List<InstanceModel> queryInstance(final String regionId, final String serviceId, final String instanceId); List<InstanceModel> queryInstances(final String regionId); List<InstanceModel> queryInstances(); List<InstanceModel> queryInstances(final String regionId, final List<String> serviceIds); List<InstanceModel> query(final String condition, final String... args); void delete(final Long... ids); void delete(final InstanceModel... instances); void delete(final List<InstanceModel> instances); void destroyServers(final List<ServerKey> serverKeys); void insert(final InstanceModel... instances); void insert(final List<InstanceModel> instances); static final InstanceDao INSTANCE; }### Answer: @Test public void testDestroyServers() { final InstanceModel instance1 = InstanceModels.newInstanceModel(); final InstanceModel instance2 = InstanceModels.newInstanceModel(); final List<InstanceModel> instances = Lists.newArrayList(instance1, instance2); instanceDao.insert(instances); List<ServerKey> serverKeys = Lists.newArrayList(); for (final InstanceModel instance : instances) { serverKeys.add(new ServerKey(instance.getRegionId(), instance.getInstanceId())); List<InstanceModel> instanceModels = query(instance); Assert.assertEquals(1, instanceModels.size()); } instanceDao.destroyServers(serverKeys); for (final InstanceModel instance : instances) { List<InstanceModel> instanceModels = query(instance); Assert.assertEquals(0, instanceModels.size()); } }
### Question: RouteRuleLogDao { public void insert(final RouteRuleLogModel... logs) { if ((logs == null) \|\| (logs.length == 0)) { return; } this.insert(Lists.newArrayList(logs)); } private RouteRuleLogDao(); List<RouteRuleLog> select(RouteRuleLogModel filter); List<RouteRuleLog> query(final String condition, final List<Object> args); void insert(final RouteRuleLogModel... logs); void insert(final List<RouteRuleLogModel> logs); static final RouteRuleLogDao INSTANCE; }### Answer: @Test public void testInsert() { final RouteRuleLogModel log1 = newModel(); final RouteRuleLogModel log2 = newModel(); final List<RouteRuleLogModel> logs = Lists.newArrayList(log1, log2); routeRuleLogDao.insert(log1, log2); for (final RouteRuleLogModel log : logs) { final List<RouteRuleLog> logModels = query(log); Assert.assertEquals(1, logModels.size()); assertLog(log, logModels.get(0)); } }
### Question: GroupDao { protected GroupModel generateGroup(GroupModel group) { GroupModel filter = new GroupModel(); filter.setServiceId(group.getServiceId()); filter.setRegionId(group.getRegionId()); filter.setZoneId(group.getZoneId()); filter.setName(group.getName()); List<GroupModel> newGroups = select(filter); if (newGroups.size() == 0) { insert(group); newGroups = select(filter); } return newGroups.get(0); } private GroupDao(); List<GroupModel> query(); List<GroupModel> select(GroupModel filter); List<GroupModel> select(List<Long> groupIds); static final GroupDao INSTANCE; }### Answer: @Test public void testGenerateGroup() { GroupModel group = newGroup(); GroupModel newGroup = groupDao.generateGroup(group); Assert.assertNotNull(newGroup.getId()); assertGroup(newGroup, group); }
### Question: ServiceContext { public synchronized boolean isAvailable() { Service service = this.service; return service != null && !CollectionValues.isNullOrEmpty(service.getInstances()); } ServiceContext(DiscoveryConfig discoveryConfig); DiscoveryConfig getDiscoveryConfig(); synchronized Service newService(); synchronized void setService(Service service); synchronized boolean deleteInstance(Instance instance); synchronized boolean updateInstance(Instance instance); synchronized boolean addInstance(Instance instance); synchronized boolean isAvailable(); synchronized Set<ServiceChangeListener> getListeners(); synchronized void addListener(final ServiceChangeListener listener); ServiceChangeEvent newServiceChangeEvent(final String changeType); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object other); }### Answer: @Test public void testIsAvailable() { ServiceContext context = new ServiceContext(_discoveryConfig); Assert.assertFalse(context.isAvailable()); Instance instance = Instances.newInstance(_serviceId); Assert.assertTrue(context.addInstance(instance)); Assert.assertEquals(1, context.newService().getInstances().size()); Assert.assertTrue(context.isAvailable()); Assert.assertTrue(context.deleteInstance(instance)); Assert.assertFalse(context.isAvailable()); }
### Question: GroupDao { protected void insertOrUpdate(final GroupModel... groups) { insertOrUpdate(Lists.newArrayList(groups)); } private GroupDao(); List<GroupModel> query(); List<GroupModel> select(GroupModel filter); List<GroupModel> select(List<Long> groupIds); static final GroupDao INSTANCE; }### Answer: @Test public void testInsertOrUpdate() { GroupModel group = newGroup(); groupDao.insertOrUpdate(group); assertGroup(group, query(group)); groupDao.insertOrUpdate(group); assertGroup(group, query(group)); }
### Question: GroupDao { protected void delete(final Long... ids) { delete(Lists.newArrayList(ids)); } private GroupDao(); List<GroupModel> query(); List<GroupModel> select(GroupModel filter); List<GroupModel> select(List<Long> groupIds); static final GroupDao INSTANCE; }### Answer: @Test public void testDelete() { GroupModel group = newGroup(); groupDao.insertOrUpdate(group); GroupModel copy1 = query(group); groupDao.delete(copy1.getId()); Assert.assertNull(query(group, 0)); groupDao.insertOrUpdate(group); GroupModel copy2 = query(group); Assert.assertEquals(copy1.getId(), copy2.getId()); assertGroup(copy1, copy2); }
### Question: GroupDao { public List<GroupModel> select(GroupModel filter) { ValueCheckers.notNull(filter, "filter"); Map<String, String> conditions = Maps.newHashMap(); conditions.put("id=?", filter.getId() == null ? null : Long.toString(filter.getId())); conditions.put("service_id=?", filter.getServiceId()); conditions.put("region_id=?", filter.getRegionId()); conditions.put("zone_id=?", filter.getZoneId()); conditions.put("name=?", filter.getName()); conditions.put("app_id=?", filter.getAppId()); conditions.put("status=?", filter.getStatus()); Set<String> removed = Sets.newHashSet(); for (String key : conditions.keySet()) { if (StringValues.isNullOrWhitespace(conditions.get(key))) { removed.add(key); } } conditions.keySet().removeAll(removed); return query(Joiner.on(" and ").join(conditions.keySet()), Lists.newArrayList(conditions.values())); } private GroupDao(); List<GroupModel> query(); List<GroupModel> select(GroupModel filter); List<GroupModel> select(List<Long> groupIds); static final GroupDao INSTANCE; }### Answer: @Test public void testSelect() { GroupModel group = newGroup(); groupDao.insertOrUpdate(group); GroupModel filter = new GroupModel(); filter.setServiceId(group.getServiceId()); filter.setName(group.getName()); GroupModel newGroup = groupDao.select(filter).get(0); assertGroup(group, newGroup); assertGroup(group, groupDao.select(Lists.newArrayList(newGroup.getId())).get(0)); }
### Question: ServiceInstanceLogDao { protected void insert(final ServiceInstanceLogModel... logs) { if ((logs == null) \|\| (logs.length == 0)) { return; } this.insert(Lists.newArrayList(logs)); } private ServiceInstanceLogDao(); List<ServiceInstanceLog> select(ServiceInstanceLogModel filter); List<ServiceInstanceLog> query(final String condition, final List<Object> args); static final ServiceInstanceLogDao INSTANCE; }### Answer: @Test public void testInsert() { final ServiceInstanceLogModel log1 = newModel(); final ServiceInstanceLogModel log2 = newModel(); final List<ServiceInstanceLogModel> logs = Lists.newArrayList(log1, log2); serviceInstanceLogDao.insert(log1, log2); for (final ServiceInstanceLogModel log : logs) { final List<ServiceInstanceLog> logModels = query(log); Assert.assertEquals(1, logModels.size()); assertLog(log, logModels.get(0)); } }
### Question: GroupTagDao { public List<GroupTagModel> query() { return DataConfig.jdbcTemplate().query("select group_id, tag, value from service_group_tag", new RowMapper<GroupTagModel>() { @Override public GroupTagModel mapRow(ResultSet rs, int i) throws SQLException { GroupTagModel tag = new GroupTagModel(); tag.setGroupId(rs.getLong(1)); tag.setTag(rs.getString(2)); tag.setValue(rs.getString(3)); return tag; } }); } private GroupTagDao(); List<GroupTagModel> query(); void delete(GroupTagModel filter); void insertOrUpdate(GroupTagModel... models); void insertOrUpdate(final List<GroupTagModel> models); static final GroupTagDao INSTANCE; }### Answer: @Test public void testQuery() throws Exception { groupTagDao.insertOrUpdate(newGroupTag()); groupTagDao.insertOrUpdate(newGroupTag()); Assert.assertTrue(groupTagDao.query().size() >= 2); }
### Question: GroupTagDao { public void delete(GroupTagModel filter) { ValueCheckers.notNull(filter, "filter"); final Map<String, String> conditions = Maps.newHashMap(); conditions.put("group_id=?", filter.getGroupId() == null ? null : Long.toString(filter.getGroupId())); conditions.put("tag=?", filter.getTag()); conditions.put("value=?", filter.getValue()); Set<String> removed = Sets.newHashSet(); for (String key : conditions.keySet()) { if (StringValues.isNullOrWhitespace(conditions.get(key))) { removed.add(key); } } conditions.keySet().removeAll(removed); if (conditions.size() == 0) { throw new IllegalStateException("forbidden operation."); } String sql = "delete from service_group_tag where " + Joiner.on(" and ").join(conditions.keySet()); DataConfig.jdbcTemplate().update(sql, new PreparedStatementSetter() { @Override public void setValues(PreparedStatement ps) throws SQLException { List<String> args = Lists.newArrayList(conditions.values()); for (int i = 0; i < args.size(); i++) { ps.setString(i + 1, args.get(i)); } } }); } private GroupTagDao(); List<GroupTagModel> query(); void delete(GroupTagModel filter); void insertOrUpdate(GroupTagModel... models); void insertOrUpdate(final List<GroupTagModel> models); static final GroupTagDao INSTANCE; }### Answer: @Test public void testDelete() throws Exception { GroupTagModel groupTag = newGroupTag(); groupTagDao.insertOrUpdate(groupTag); assertGroupOperation(groupTag, query(groupTag)); groupTagDao.delete(groupTag); Assert.assertNull(query(groupTag)); }
### Question: GroupTagDao { public void insertOrUpdate(GroupTagModel... models) { insertOrUpdate(Lists.newArrayList(models)); } private GroupTagDao(); List<GroupTagModel> query(); void delete(GroupTagModel filter); void insertOrUpdate(GroupTagModel... models); void insertOrUpdate(final List<GroupTagModel> models); static final GroupTagDao INSTANCE; }### Answer: @Test public void testInsertOrUpdate() throws Exception { GroupTagModel GroupTag = newGroupTag(); groupTagDao.insertOrUpdate(GroupTag); groupTagDao.insertOrUpdate(GroupTag); assertGroupOperation(GroupTag, query(GroupTag)); }
### Question: GroupTagLogDao { public void insert(final GroupTagLogModel... logs) { if ((logs == null) \|\| (logs.length == 0)) { return; } this.insert(Lists.newArrayList(logs)); } private GroupTagLogDao(); List<GroupTagLog> query(final String condition, final Object... args); void insert(final GroupTagLogModel... logs); void insert(final List<GroupTagLogModel> logs); static final GroupTagLogDao INSTANCE; }### Answer: @Test public void testInsert() { final GroupTagLogModel log1 = newModel(); final GroupTagLogModel log2 = newModel(); final List<GroupTagLogModel> logs = Lists.newArrayList(log1, log2); groupTagLogDao.insert(log1, log2); for (final GroupTagLogModel log : logs) { final List<GroupTagLog> ls = query(log); Assert.assertTrue(ls.size() == 1); assertLog(log, ls.get(0)); } Assert.assertTrue(groupTagLogDao.query("create_time >= DATE_SUB(now(), INTERVAL ? MINUTE)", "2").size() >= logs.size()); Assert.assertTrue(groupTagLogDao.query("create_time > now()").size() == 0); Assert.assertTrue(groupTagLogDao.query("create_time <= now()").size() >= logs.size()); }
### Question: RouteRuleDao { protected void insertOrUpdate(RouteRuleModel... models) { insertOrUpdate(Lists.newArrayList(models)); } List<RouteRuleModel> query(); List<RouteRuleModel> select(RouteRuleModel filter); List<RouteRuleModel> select(List<Long> groupIds); static final RouteRuleDao INSTANCE; }### Answer: @Test public void testInsertOrUpdate() { RouteRuleModel routeRule = newRouteRule(); routeRuleDao.insertOrUpdate(routeRule); assertRouteRule(routeRule, query(routeRule)); routeRuleDao.insertOrUpdate(routeRule); assertRouteRule(routeRule, query(routeRule)); }
### Question: RouteRuleDao { protected void delete(final Long... ids) { delete(Lists.newArrayList(ids)); } List<RouteRuleModel> query(); List<RouteRuleModel> select(RouteRuleModel filter); List<RouteRuleModel> select(List<Long> groupIds); static final RouteRuleDao INSTANCE; }### Answer: @Test public void testDelete() { RouteRuleModel routeRule = newRouteRule(); routeRuleDao.insertOrUpdate(routeRule); RouteRuleModel copy1 = query(routeRule); routeRuleDao.delete(copy1.getId()); Assert.assertNull(query(routeRule, 0)); routeRuleDao.insertOrUpdate(routeRule); RouteRuleModel copy2 = query(routeRule); Assert.assertEquals(copy1.getId(), copy2.getId()); assertRouteRule(copy1, copy2); }
### Question: DiscoveryClientImpl implements DiscoveryClient { @Override public Service getService(final DiscoveryConfig discoveryConfig) { DiscoveryConfigChecker.DEFAULT.check(discoveryConfig, "discoveryConfig"); return serviceRepository.getService(discoveryConfig); } DiscoveryClientImpl(final String clientId, final ArtemisClientManagerConfig managerConfig); @Override Service getService(final DiscoveryConfig discoveryConfig); @Override void registerServiceChangeListener(final DiscoveryConfig discoveryConfig, final ServiceChangeListener listener); }### Answer: @Test public void testGetService() { final String serviceId = ArtemisClientConstants.RegistryService.Net.serviceKey; final DiscoveryConfig discoveryConfig = new DiscoveryConfig(serviceId); final Service service = _discoveryClientImpl.getService(discoveryConfig); Assert.assertEquals(serviceId, service.getServiceId()); Assert.assertNotNull(service.getInstances()); Assert.assertTrue(service.getInstances().size() >= 0); }
### Question: RouteRuleDao { public List<RouteRuleModel> select(RouteRuleModel filter) { ValueCheckers.notNull(filter, "filter"); Map<String, String> conditions = Maps.newHashMap(); conditions.put("id=?", filter.getId() == null ? null : Long.toString(filter.getId())); conditions.put("service_id=?", filter.getServiceId()); conditions.put("name=?", filter.getName()); conditions.put("status=?", filter.getStatus()); Set<String> removed = Sets.newHashSet(); for (String key : conditions.keySet()) { if (StringValues.isNullOrWhitespace(conditions.get(key))) { removed.add(key); } } conditions.keySet().removeAll(removed); return query(Joiner.on(" and ").join(conditions.keySet()), Lists.newArrayList(conditions.values())); } List<RouteRuleModel> query(); List<RouteRuleModel> select(RouteRuleModel filter); List<RouteRuleModel> select(List<Long> groupIds); static final RouteRuleDao INSTANCE; }### Answer: @Test public void testSelect() { RouteRuleModel routeRule = newRouteRule(); routeRuleDao.insertOrUpdate(routeRule); RouteRuleModel filter = new RouteRuleModel(); filter.setName(routeRule.getName()); filter.setServiceId(routeRule.getServiceId()); Assert.assertEquals(1, routeRuleDao.select(filter).size()); Assert.assertEquals(1, routeRuleDao.select(Lists.newArrayList(routeRuleDao.select(filter).get(0).getId())).size()); }
### Question: ServiceInstanceDao { public List<ServiceInstanceModel> query() { final String sql = "SELECT service_id, instance_id, ip, machine_name, metadata, port, protocol, region_id, zone_id, healthy_check_url, url, group_id from service_instance"; return DataConfig.jdbcTemplate().query(sql, new RowMapper<ServiceInstanceModel>() { @Override public ServiceInstanceModel mapRow(final ResultSet rs, final int rowNum) throws SQLException { ServiceInstanceModel serviceInstance = new ServiceInstanceModel(); serviceInstance.setServiceId(rs.getString(1)); serviceInstance.setInstanceId(rs.getString(2)); serviceInstance.setIp(rs.getString(3)); serviceInstance.setMachineName(rs.getString(4)); serviceInstance.setMetadata(rs.getString(5)); serviceInstance.setPort(rs.getInt(6)); serviceInstance.setProtocol(rs.getString(7)); serviceInstance.setRegionId(rs.getString(8)); serviceInstance.setZoneId(rs.getString(9)); serviceInstance.setHealthCheckUrl(rs.getString(10)); serviceInstance.setUrl(rs.getString(11)); serviceInstance.setGroupId(rs.getString(12)); return serviceInstance; } }); } private ServiceInstanceDao(); List<ServiceInstanceModel> query(); List<ServiceInstanceModel> select(ServiceInstanceModel filter); List<ServiceInstanceModel> select(List<Long> groupIds); static final ServiceInstanceDao INSTANCE; }### Answer: @Test public void testQuery() throws Exception { serviceInstanceDao.insertOrUpdate(newServiceInstance()); serviceInstanceDao.insertOrUpdate(newServiceInstance()); Assert.assertTrue(serviceInstanceDao.query().size() >= 2); }
### Question: ServiceInstanceDao { protected void delete(final Long... ids) { delete(Lists.newArrayList(ids)); } private ServiceInstanceDao(); List<ServiceInstanceModel> query(); List<ServiceInstanceModel> select(ServiceInstanceModel filter); List<ServiceInstanceModel> select(List<Long> groupIds); static final ServiceInstanceDao INSTANCE; }### Answer: @Test public void testDelete() throws Exception { ServiceInstanceModel serviceInstance = newServiceInstance(); serviceInstanceDao.insertOrUpdate(serviceInstance); ServiceInstanceModel newServiceInstance = query(serviceInstance); assertServiceInstance(serviceInstance, query(serviceInstance)); serviceInstanceDao.delete(newServiceInstance.getId()); Assert.assertNull(query(serviceInstance, 0)); }
### Question: ServiceInstanceDao { protected void deleteByFilters(final List<ServiceInstanceModel> filters) { checkInsertOrUpdateArgument(filters); DataConfig.jdbcTemplate().batchUpdate("delete from service_instance where service_id = ? and instance_id=?", new BatchPreparedStatementSetter() { @Override public int getBatchSize() { return filters.size(); } @Override public void setValues(final PreparedStatement ps, final int i) throws SQLException { final ServiceInstanceModel filter = filters.get(i); ps.setString(1, filter.getServiceId()); ps.setString(2, filter.getInstanceId()); } }); } private ServiceInstanceDao(); List<ServiceInstanceModel> query(); List<ServiceInstanceModel> select(ServiceInstanceModel filter); List<ServiceInstanceModel> select(List<Long> groupIds); static final ServiceInstanceDao INSTANCE; }### Answer: @Test public void testDeleteByFilters() throws Exception { ServiceInstanceModel serviceInstance1 = newServiceInstance(); ServiceInstanceModel serviceInstance2 = newServiceInstance(); serviceInstanceDao.insertOrUpdate(serviceInstance1, serviceInstance2); query(serviceInstance1, 1); query(serviceInstance2, 1); serviceInstanceDao.deleteByFilters(Lists.newArrayList(serviceInstance1, serviceInstance2)); query(serviceInstance1, 0); query(serviceInstance2, 0); }
### Question: ServiceInstanceDao { protected void insertOrUpdate(final ServiceInstanceModel... groupInstances) { insertOrUpdate(Lists.newArrayList(groupInstances)); } private ServiceInstanceDao(); List<ServiceInstanceModel> query(); List<ServiceInstanceModel> select(ServiceInstanceModel filter); List<ServiceInstanceModel> select(List<Long> groupIds); static final ServiceInstanceDao INSTANCE; }### Answer: @Test public void testInsertOrUpdate() throws Exception { ServiceInstanceModel serviceInstance = newServiceInstance(); serviceInstanceDao.insertOrUpdate(serviceInstance); serviceInstanceDao.insertOrUpdate(serviceInstance); assertServiceInstance(serviceInstance, query(serviceInstance)); }
### Question: GroupOperationDao { public List<GroupOperationModel> query() { return DataConfig.jdbcTemplate().query("select group_id, operation from service_group_operation", new RowMapper<GroupOperationModel>() { @Override public GroupOperationModel mapRow(ResultSet rs, int i) throws SQLException { GroupOperationModel groupOperation = new GroupOperationModel(); groupOperation.setGroupId(rs.getLong(1)); groupOperation.setOperation(rs.getString(2)); return groupOperation; } }); } private GroupOperationDao(); List<GroupOperationModel> query(); static final GroupOperationDao INSTANCE; }### Answer: @Test public void testQuery() throws Exception { groupOperationDao.insertOrUpdate(newGroupOperation()); groupOperationDao.insertOrUpdate(newGroupOperation()); Assert.assertTrue(groupOperationDao.query().size() >= 2); }
### Question: GroupOperationDao { protected void delete(GroupOperationModel groupOperation) { delete(Lists.newArrayList(groupOperation)); } private GroupOperationDao(); List<GroupOperationModel> query(); static final GroupOperationDao INSTANCE; }### Answer: @Test public void testDelete() throws Exception { GroupOperationModel groupOperation = newGroupOperation(); groupOperationDao.insertOrUpdate(groupOperation); assertGroupOperation(groupOperation, query(groupOperation)); groupOperationDao.delete(groupOperation); Assert.assertNull(query(groupOperation)); }
### Question: DiscoveryClientImpl implements DiscoveryClient { @Override public void registerServiceChangeListener(final DiscoveryConfig discoveryConfig, final ServiceChangeListener listener) { DiscoveryConfigChecker.DEFAULT.check(discoveryConfig, "discoveryConfig"); NullArgumentChecker.DEFAULT.check(listener, "listener"); serviceRepository.registerServiceChangeListener(discoveryConfig, listener); } DiscoveryClientImpl(final String clientId, final ArtemisClientManagerConfig managerConfig); @Override Service getService(final DiscoveryConfig discoveryConfig); @Override void registerServiceChangeListener(final DiscoveryConfig discoveryConfig, final ServiceChangeListener listener); }### Answer: @Test public void registerServiceChangeListener() { final Map<String, DefaultServiceChangeListener> registerServices = Maps.newHashMap(); final String serviceId = Services.newServiceId(); registerServices.put("framework.soa.v1.registryservice", new DefaultServiceChangeListener()); registerServices.put("framework.soa.testservice.v2.testservice", new DefaultServiceChangeListener()); registerServices.put("framework.soa.test.v1.testportal", new DefaultServiceChangeListener()); registerServices.put(serviceId, new DefaultServiceChangeListener()); for (final Map.Entry<String, DefaultServiceChangeListener> entry : registerServices.entrySet()) { final DiscoveryConfig discoveryConfig = new DiscoveryConfig(entry.getKey()); _discoveryClientImpl.registerServiceChangeListener(discoveryConfig, entry.getValue()); } for (final Map.Entry<String, DefaultServiceChangeListener> entry : registerServices.entrySet()) { final List<ServiceChangeEvent> serviceChangeEvents = entry.getValue().getServiceChangeEvents(); Assert.assertEquals(0, serviceChangeEvents.size()); } }
### Question: GroupOperationDao { protected void insertOrUpdate(GroupOperationModel... operationModels) { insertOrUpdate(Lists.newArrayList(operationModels)); } private GroupOperationDao(); List<GroupOperationModel> query(); static final GroupOperationDao INSTANCE; }### Answer: @Test public void testInsertOrUpdate() throws Exception { GroupOperationModel groupOperation = newGroupOperation(); groupOperationDao.insertOrUpdate(groupOperation); groupOperationDao.insertOrUpdate(groupOperation); assertGroupOperation(groupOperation, query(groupOperation)); }
### Question: GroupInstanceDao { protected void delete(final Long... ids) { delete(Lists.newArrayList(ids)); } private GroupInstanceDao(); List<GroupInstanceModel> query(); List<GroupInstanceModel> select(GroupInstanceModel filter); List<GroupInstanceModel> select(List<Long> groupIds); static final GroupInstanceDao INSTANCE; }### Answer: @Test public void testDelete() { GroupInstanceModel groupInstance = newGroupInstance(); groupInstanceDao.insert(groupInstance); GroupInstanceModel copy1 = query(groupInstance); groupInstanceDao.delete(copy1.getId()); Assert.assertNull(query(groupInstance, 0)); }
### Question: GroupInstanceDao { protected void deleteByFilters(final List<GroupInstanceModel> filters){ checkInsertOrUpdateArgument(filters); DataConfig.jdbcTemplate().batchUpdate("delete from service_group_instance where group_id = ? and instance_id=?", new BatchPreparedStatementSetter() { @Override public int getBatchSize() { return filters.size(); } @Override public void setValues(final PreparedStatement ps, final int i) throws SQLException { final GroupInstanceModel filter = filters.get(i); ps.setLong(1, filter.getGroupId()); ps.setString(2, filter.getInstanceId()); } }); } private GroupInstanceDao(); List<GroupInstanceModel> query(); List<GroupInstanceModel> select(GroupInstanceModel filter); List<GroupInstanceModel> select(List<Long> groupIds); static final GroupInstanceDao INSTANCE; }### Answer: @Test public void testDeleteByFilters() { GroupInstanceModel groupInstance1 = newGroupInstance(); GroupInstanceModel groupInstance2 = newGroupInstance(); groupInstanceDao.insert(groupInstance1, groupInstance2); query(groupInstance1, 1); query(groupInstance2, 1); groupInstanceDao.deleteByFilters(Lists.newArrayList(groupInstance1, groupInstance2)); query(groupInstance1, 0); query(groupInstance2, 0); }
### Question: GroupInstanceDao { public List<GroupInstanceModel> select(GroupInstanceModel filter) { ValueCheckers.notNull(filter, "filter"); Map<String, String> conditions = Maps.newHashMap(); conditions.put("id=?", filter.getId() == null ? null : Long.toString(filter.getId())); conditions.put("group_id=?", filter.getGroupId() == null ? null : Long.toString(filter.getGroupId())); conditions.put("instance_id=?", filter.getInstanceId()); Set<String> removed = Sets.newHashSet(); for (String key : conditions.keySet()) { if (StringValues.isNullOrWhitespace(conditions.get(key))) { removed.add(key); } } conditions.keySet().removeAll(removed); return query(Joiner.on(" and ").join(conditions.keySet()), Lists.newArrayList(conditions.values())); } private GroupInstanceDao(); List<GroupInstanceModel> query(); List<GroupInstanceModel> select(GroupInstanceModel filter); List<GroupInstanceModel> select(List<Long> groupIds); static final GroupInstanceDao INSTANCE; }### Answer: @Test public void testSelect() { GroupInstanceModel groupInstance = newGroupInstance(); groupInstanceDao.insert(groupInstance); GroupInstanceModel filter = new GroupInstanceModel(); filter.setGroupId(groupInstance.getGroupId()); filter.setInstanceId(groupInstance.getInstanceId()); assertGroupInstance(groupInstance, groupInstanceDao.select(filter).get(0)); }
### Question: RouteRuleGroupDao { protected void insertOrUpdate(final RouteRuleGroupModel... models) { insertOrUpdate(Lists.newArrayList(models)); } List<RouteRuleGroupModel> query(); RouteRuleGroupModel generateGroup(RouteRuleGroupModel routeRuleGroup); List<RouteRuleGroupModel> select(RouteRuleGroupModel filter); List<RouteRuleGroupModel> select(List<Long> groupIds); static final RouteRuleGroupDao INSTANCE; }### Answer: @Test public void testInsertOrUpdate() { for (RouteRuleGroupModel routeRuleGroup : newRouteRuleGroups()) { routeRuleGroupDao.insertOrUpdate(routeRuleGroup); assertRouteRuleGroup(routeRuleGroup, query(routeRuleGroup)); routeRuleGroup.setUnreleasedWeight(null); routeRuleGroupDao.insertOrUpdate(routeRuleGroup); assertRouteRuleGroup(routeRuleGroup, query(routeRuleGroup)); } }
### Question: RouteRuleGroupDao { protected void insert(final RouteRuleGroupModel... models) { insert(Lists.newArrayList(models)); } List<RouteRuleGroupModel> query(); RouteRuleGroupModel generateGroup(RouteRuleGroupModel routeRuleGroup); List<RouteRuleGroupModel> select(RouteRuleGroupModel filter); List<RouteRuleGroupModel> select(List<Long> groupIds); static final RouteRuleGroupDao INSTANCE; }### Answer: @Test public void testInsert() { for (RouteRuleGroupModel routeRuleGroup : newRouteRuleGroups()) { routeRuleGroupDao.insert(routeRuleGroup); assertRouteRuleGroup(routeRuleGroup, query(routeRuleGroup)); routeRuleGroup.setUnreleasedWeight(null); routeRuleGroupDao.insert(routeRuleGroup); assertRouteRuleGroup(routeRuleGroup, query(routeRuleGroup)); } }
### Question: RouteRuleGroupDao { protected void delete(final Long... ids) { delete(Lists.newArrayList(ids)); } List<RouteRuleGroupModel> query(); RouteRuleGroupModel generateGroup(RouteRuleGroupModel routeRuleGroup); List<RouteRuleGroupModel> select(RouteRuleGroupModel filter); List<RouteRuleGroupModel> select(List<Long> groupIds); static final RouteRuleGroupDao INSTANCE; }### Answer: @Test public void testDelete() { for (RouteRuleGroupModel routeRuleGroup : newRouteRuleGroups()) { routeRuleGroupDao.insertOrUpdate(routeRuleGroup); RouteRuleGroupModel copy = query(routeRuleGroup); routeRuleGroupDao.delete(copy.getId()); Assert.assertNull(query(routeRuleGroup, 0)); } }
### Question: RouteRuleGroupDao { public List<RouteRuleGroupModel> select(RouteRuleGroupModel filter) { ValueCheckers.notNull(filter, "filter"); Map<String, Long> conditions = Maps.newHashMap(); conditions.put("id=?", filter.getId()); conditions.put("route_rule_id=?", filter.getRouteRuleId()); conditions.put("group_id=?", filter.getGroupId()); Set<String> removed = Sets.newHashSet(); for (String key : conditions.keySet()) { if (conditions.get(key) == null) { removed.add(key); } } conditions.keySet().removeAll(removed); return query(Joiner.on(" and ").join(conditions.keySet()), Lists.newArrayList(conditions.values())); } List<RouteRuleGroupModel> query(); RouteRuleGroupModel generateGroup(RouteRuleGroupModel routeRuleGroup); List<RouteRuleGroupModel> select(RouteRuleGroupModel filter); List<RouteRuleGroupModel> select(List<Long> groupIds); static final RouteRuleGroupDao INSTANCE; }### Answer: @Test public void testSelect() { for (RouteRuleGroupModel routeRuleGroup : newRouteRuleGroups()) { routeRuleGroupDao.insertOrUpdate(routeRuleGroup); RouteRuleGroupModel filter = new RouteRuleGroupModel(); filter.setGroupId(routeRuleGroup.getGroupId()); Assert.assertEquals(1, routeRuleGroupDao.select(filter).size()); Assert.assertEquals(1, routeRuleGroupDao.select(Lists.newArrayList(routeRuleGroupDao.select(filter).get(0).getId())).size()); } }
### Question: RouteRuleGroupDao { protected void release(final List<RouteRuleGroupModel> models) { checkReleaseArgument(models); DataConfig.jdbcTemplate().batchUpdate("update service_route_rule_group set weight = unreleased_weight where route_rule_id=? and group_id=?", new BatchPreparedStatementSetter() { @Override public void setValues(PreparedStatement ps, int i) throws SQLException { RouteRuleGroupModel model = models.get(i); ps.setLong(1, model.getRouteRuleId()); ps.setLong(2, model.getGroupId()); } @Override public int getBatchSize() { return models.size(); } }); } List<RouteRuleGroupModel> query(); RouteRuleGroupModel generateGroup(RouteRuleGroupModel routeRuleGroup); List<RouteRuleGroupModel> select(RouteRuleGroupModel filter); List<RouteRuleGroupModel> select(List<Long> groupIds); static final RouteRuleGroupDao INSTANCE; }### Answer: @Test public void testRelease() { for (RouteRuleGroupModel routeRuleGroup : newRouteRuleGroups()) { routeRuleGroupDao.insertOrUpdate(routeRuleGroup); RouteRuleGroupModel valueBeforeReleased = query(routeRuleGroup); assertRouteRuleGroup(routeRuleGroup, valueBeforeReleased); if (routeRuleGroup.getUnreleasedWeight() != null) { Assert.assertNull(valueBeforeReleased.getWeight()); Assert.assertNotEquals(routeRuleGroup.getUnreleasedWeight(), valueBeforeReleased.getWeight()); } else { Assert.assertEquals(routeRuleGroup.getUnreleasedWeight(), valueBeforeReleased.getWeight()); } routeRuleGroupDao.release(Lists.newArrayList(valueBeforeReleased)); RouteRuleGroupModel valueAfterReleased = query(routeRuleGroup); assertRouteRuleGroup(routeRuleGroup, valueAfterReleased); Assert.assertEquals(routeRuleGroup.getUnreleasedWeight(), valueAfterReleased.getWeight()); } }
### Question: RouteRuleGroupDao { protected void publish(final RouteRuleGroupModel... models) { publish(Lists.newArrayList(models)); } List<RouteRuleGroupModel> query(); RouteRuleGroupModel generateGroup(RouteRuleGroupModel routeRuleGroup); List<RouteRuleGroupModel> select(RouteRuleGroupModel filter); List<RouteRuleGroupModel> select(List<Long> groupIds); static final RouteRuleGroupDao INSTANCE; }### Answer: @Test public void testPublish() { for (RouteRuleGroupModel routeRuleGroup : newRouteRuleGroups()) { routeRuleGroupDao.publish(routeRuleGroup); RouteRuleGroupModel published = query(routeRuleGroup); Assert.assertEquals(routeRuleGroup.getRouteRuleId(), published.getRouteRuleId()); Assert.assertEquals(routeRuleGroup.getGroupId(), published.getGroupId()); Assert.assertEquals(null, published.getUnreleasedWeight()); Assert.assertEquals(routeRuleGroup.getWeight(), published.getWeight()); } }
### Question: ArtemisDiscoveryHttpClient extends ArtemisHttpClient { public Service getService(final DiscoveryConfig discoveryConfig) { Preconditions.checkArgument(discoveryConfig != null, "discoveryConfig"); final List<Service> services = getServices(Lists.newArrayList(discoveryConfig)); if (services.size() > 0) { return services.get(0); } throw new RuntimeException("not found any service by discoveryConfig:" + discoveryConfig); } ArtemisDiscoveryHttpClient(final ArtemisClientConfig config); Service getService(final DiscoveryConfig discoveryConfig); List<Service> getServices(final List<DiscoveryConfig> discoveryConfigs); }### Answer: @Test public void testGetService_ShouldReturnEmptyInstances() { Assert.assertTrue(CollectionUtils.isEmpty(_client.getService(Services.newDiscoverConfig()).getInstances())); } @Test public void testGetService_ShouldReturnIntances() throws Exception { final Service service = _client.getService(new DiscoveryConfig(ArtemisClientConstants.RegistryService.Net.serviceKey)); Assert.assertNotNull(service); Assert.assertTrue(service.getInstances().size() > 0); }
### Question: GroupOperationLogDao { public void insert(final GroupOperationLogModel... logs) { if ((logs == null) \|\| (logs.length == 0)) { return; } this.insert(Lists.newArrayList(logs)); } private GroupOperationLogDao(); List<GroupOperationLog> select(GroupOperationLogModel filter, Boolean complete); List<GroupOperationLog> query(final String condition, final List<Object> args); void insert(final GroupOperationLogModel... logs); void insert(final List<GroupOperationLogModel> logs); static final GroupOperationLogDao INSTANCE; }### Answer: @Test public void testInsert() { final GroupOperationLogModel log1 = newModel(); final GroupOperationLogModel log2 = newModel(); log1.setComplete(true); log2.setComplete(true); final List<GroupOperationLogModel> logs = Lists.newArrayList(log1, log2); groupOperationLogDao.insert(log1, log2); for (final GroupOperationLogModel log : logs) { final List<GroupOperationLog> logModels = query(log); Assert.assertEquals(1, logModels.size()); assertLog(log, logModels.get(0)); } log1.setComplete(false); log2.setComplete(false); groupOperationLogDao.insert(log1, log2); for (final GroupOperationLogModel log : logs) { final List<GroupOperationLog> logModels = query(log); Assert.assertEquals(1, logModels.size()); assertLog(log, logModels.get(0)); } }
### Question: RouteRuleGroupLogDao { public void insert(final RouteRuleGroupLogModel... logs) { if ((logs == null) \|\| (logs.length == 0)) { return; } this.insert(Lists.newArrayList(logs)); } private RouteRuleGroupLogDao(); List<RouteRuleGroupLog> select(RouteRuleGroupLogModel filter); List<RouteRuleGroupLog> query(final String condition, final List<Object> args); void insert(final RouteRuleGroupLogModel... logs); void insert(final List<RouteRuleGroupLogModel> logs); static final RouteRuleGroupLogDao INSTANCE; }### Answer: @Test public void testInsert() { final RouteRuleGroupLogModel log1 = newModel(); final RouteRuleGroupLogModel log2 = newModel(); final List<RouteRuleGroupLogModel> logs = Lists.newArrayList(log1, log2); routeRuleGroupLogDao.insert(log1, log2); for (final RouteRuleGroupLogModel log : logs) { final List<RouteRuleGroupLog> logModels = query(log); Assert.assertEquals(1, logModels.size()); assertLog(log, logModels.get(0)); } }
### Question: GroupInstanceLogDao { protected void insert(final GroupInstanceLogModel... logs) { if ((logs == null) \|\| (logs.length == 0)) { return; } this.insert(Lists.newArrayList(logs)); } private GroupInstanceLogDao(); List<GroupInstanceLog> select(GroupInstanceLogModel filter); List<GroupInstanceLog> query(final String condition, final List<Object> args); static final GroupInstanceLogDao INSTANCE; }### Answer: @Test public void testInsert() { final GroupInstanceLogModel log1 = newModel(); final GroupInstanceLogModel log2 = newModel(); final List<GroupInstanceLogModel> logs = Lists.newArrayList(log1, log2); groupInstanceLogDao.insert(log1, log2); for (final GroupInstanceLogModel log : logs) { final List<GroupInstanceLog> logModels = query(log); Assert.assertEquals(1, logModels.size()); assertLog(log, logModels.get(0)); } }
### Question: GroupLogDao { public void insert(final GroupLogModel... logs) { if ((logs == null) \|\| (logs.length == 0)) { return; } this.insert(Lists.newArrayList(logs)); } private GroupLogDao(); List<GroupLog> select(GroupLogModel filter); List<GroupLog> query(final String condition, final List<Object> args); void insert(final GroupLogModel... logs); void insert(final List<GroupLogModel> logs); static final GroupLogDao INSTANCE; }### Answer: @Test public void testInsert() { final GroupLogModel log1 = newModel(); final GroupLogModel log2 = newModel(); final List<GroupLogModel> logs = Lists.newArrayList(log1, log2); groupLogDao.insert(log1, log2); for (final GroupLogModel log : logs) { final List<GroupLog> logModels = query(log); Assert.assertEquals(1, logModels.size()); assertLog(log, logModels.get(0)); } }
### Question: ZoneOperationLogDao { public void insert(final ZoneOperationLogModel... logs) { if ((logs == null) \|\| (logs.length == 0)) { return; } this.insert(Lists.newArrayList(logs)); } private ZoneOperationLogDao(); List<ZoneOperationLog> select(ZoneOperationLogModel filter, Boolean complete); List<ZoneOperationLog> query(final String condition, final List<String> args); void insert(final ZoneOperationLogModel... logs); void insert(final List<ZoneOperationLogModel> logs); static final ZoneOperationLogDao INSTANCE; }### Answer: @Test public void testInsert() { final ZoneOperationLogModel log1 = newZoneOperationLogModel(); final ZoneOperationLogModel log2 = newZoneOperationLogModel(); log1.setComplete(true); log2.setComplete(true); final List<ZoneOperationLogModel> logs = Lists.newArrayList(log1, log2); zoneOperationLogDao.insert(log1, log2); for (final ZoneOperationLogModel log : logs) { final List<ZoneOperationLog> logModels = query(log); Assert.assertEquals(1, logModels.size()); assertZoneOperationLog(log, logModels.get(0)); } log1.setComplete(false); log2.setComplete(false); zoneOperationLogDao.insert(log1, log2); for (final ZoneOperationLogModel log : logs) { final List<ZoneOperationLog> logModels = query(log); Assert.assertEquals(1, logModels.size()); assertZoneOperationLog(log, logModels.get(0)); } }
### Question: ZoneOperationDao { public void insertOrUpdate(ZoneOperationModel... operationModels) { insertOrUpdate(Lists.newArrayList(operationModels)); } private ZoneOperationDao(); List<ZoneOperationModel> query(); void delete(final ZoneOperationModel... zoneOperations); void delete(final List<ZoneOperationModel> zoneOperations); void insertOrUpdate(ZoneOperationModel... operationModels); void insertOrUpdate(final List<ZoneOperationModel> models); List<ZoneOperationModel> select(ZoneOperationModel filter); static final ZoneOperationDao INSTANCE; }### Answer: @Test public void testInsertOrUpdate() { ZoneOperationModel zone = newZoneOperation(); zoneOperationDao.insertOrUpdate(zone); assertZoneOperation(zone, query(zone)); zoneOperationDao.insertOrUpdate(zone); assertZoneOperation(zone, query(zone)); }
### Question: ZoneOperationDao { public void delete(final ZoneOperationModel... zoneOperations) { delete(Lists.newArrayList(zoneOperations)); } private ZoneOperationDao(); List<ZoneOperationModel> query(); void delete(final ZoneOperationModel... zoneOperations); void delete(final List<ZoneOperationModel> zoneOperations); void insertOrUpdate(ZoneOperationModel... operationModels); void insertOrUpdate(final List<ZoneOperationModel> models); List<ZoneOperationModel> select(ZoneOperationModel filter); static final ZoneOperationDao INSTANCE; }### Answer: @Test public void testDelete() { ZoneOperationModel zone = newZoneOperation(); zoneOperationDao.insertOrUpdate(zone); ZoneOperationModel copy1 = query(zone); zoneOperationDao.delete(zone); Assert.assertNull(query(zone, 0)); zoneOperationDao.insertOrUpdate(zone); ZoneOperationModel copy2 = query(zone); assertZoneOperation(copy1, copy2); }
### Question: ZoneOperationDao { public List<ZoneOperationModel> select(ZoneOperationModel filter) { ValueCheckers.notNull(filter, "filter"); Map<String, String> conditions = Maps.newHashMap(); conditions.put("id=?", filter.getId() == null ? null : Long.toString(filter.getId())); conditions.put("service_id=?", filter.getServiceId()); conditions.put("region_id=?", filter.getRegionId()); conditions.put("zone_id=?", filter.getZoneId()); conditions.put("operation=?", filter.getOperation()); Set<String> removed = Sets.newHashSet(); for (String key : conditions.keySet()) { if (StringValues.isNullOrWhitespace(conditions.get(key))) { removed.add(key); } } conditions.keySet().removeAll(removed); return query(Joiner.on(" and ").join(conditions.keySet()), Lists.newArrayList(conditions.values())); } private ZoneOperationDao(); List<ZoneOperationModel> query(); void delete(final ZoneOperationModel... zoneOperations); void delete(final List<ZoneOperationModel> zoneOperations); void insertOrUpdate(ZoneOperationModel... operationModels); void insertOrUpdate(final List<ZoneOperationModel> models); List<ZoneOperationModel> select(ZoneOperationModel filter); static final ZoneOperationDao INSTANCE; }### Answer: @Test public void testSelect() { ZoneOperationModel zone = newZoneOperation(); zoneOperationDao.insertOrUpdate(zone); ZoneOperationModel filter = new ZoneOperationModel(); filter.setServiceId(zone.getServiceId()); filter.setZoneId(zone.getZoneId()); assertZoneOperation(zone, zoneOperationDao.select(filter).get(0)); }
### Question: SearchTree { public V get(List<K> cascadingFactors) { if (CollectionValues.isNullOrEmpty(cascadingFactors)) { return value; } List<K> factors = Lists.newArrayList(cascadingFactors); SearchTree<K, V> g = children.get(factors.remove(0)); if (g == null) { return defaultChildrenValue; } return g.get(factors); } V getValue(); void setValue(V value); V getDefaultChildrenValue(); void setDefaultChildrenValue(V defaultChildrenValue); V get(List<K> cascadingFactors); V first(List<K> cascadingFactors); void add(List<K> cascadingFactors, V value); void put(K childKey, SearchTree<K, V> searchTree); }### Answer: @Test public void testGet() throws Exception { Assert.assertNull(tree.get(null)); Assert.assertNull(tree.get(new ArrayList<String>())); Assert.assertEquals("key1", tree.get(key1)); Assert.assertEquals(null, tree.get(key2)); Assert.assertEquals("key3", tree.get(key3)); Assert.assertEquals(null, tree.get(key4)); Assert.assertEquals("key5", tree.get(key5)); Assert.assertEquals(null, tree.get(key6)); Assert.assertEquals("key7", tree.get(key7)); Assert.assertEquals(null, tree.get(key8)); }
### Question: SearchTree { public void add(List<K> cascadingFactors, V value) { if (CollectionValues.isNullOrEmpty(cascadingFactors)) { this.value = value; return; } List<K> factors = Lists.newArrayList(cascadingFactors); K factor = factors.remove(0); ValueCheckers.notNull(factor, "factor"); SearchTree<K, V> child = children.get(factor); if (child == null) { child = new SearchTree<>(); children.put(factor, child); } child.add(factors, value); } V getValue(); void setValue(V value); V getDefaultChildrenValue(); void setDefaultChildrenValue(V defaultChildrenValue); V get(List<K> cascadingFactors); V first(List<K> cascadingFactors); void add(List<K> cascadingFactors, V value); void put(K childKey, SearchTree<K, V> searchTree); }### Answer: @Test public void testAdd() throws Exception { SearchTree<String,String> tree = new SearchTree<>(); tree.add(null, null); }
### Question: SearchTree { public V first(List<K> cascadingFactors) { if (value != null \|\| CollectionValues.isNullOrEmpty(cascadingFactors)) { return value; } List<K> factors = Lists.newArrayList(cascadingFactors); SearchTree<K, V> g = children.get(factors.remove(0)); if (g == null) { return defaultChildrenValue; } return g.first(factors); } V getValue(); void setValue(V value); V getDefaultChildrenValue(); void setDefaultChildrenValue(V defaultChildrenValue); V get(List<K> cascadingFactors); V first(List<K> cascadingFactors); void add(List<K> cascadingFactors, V value); void put(K childKey, SearchTree<K, V> searchTree); }### Answer: @Test public void testFirst() throws Exception { Assert.assertNull(tree.first(null)); Assert.assertNull(tree.first(new ArrayList<String>())); Assert.assertEquals("key1", tree.first(key1)); Assert.assertEquals("key1", tree.first(key2)); Assert.assertEquals("key1", tree.first(key3)); Assert.assertEquals("key1", tree.first(key4)); Assert.assertEquals("key5", tree.first(key5)); Assert.assertEquals("key1", tree.first(key6)); Assert.assertEquals("key1", tree.first(key7)); Assert.assertEquals("key1", tree.first(key8)); }
### Question: ServiceGroups { public static int fixWeight(Integer weight) { if (weight == null \|\| weight < MIN_WEIGHT_VALUE) { return DEFAULT_WEIGHT_VALUE; } if (weight > MAX_WEIGHT_VALUE) { return MAX_WEIGHT_VALUE; } return weight; } private ServiceGroups(); static int fixWeight(Integer weight); static boolean isDefaultGroupId(String groupId); static boolean isGroupCanaryInstance(String groupKey, Instance instance); static boolean isLocalZone(ServiceGroup serviceGroup); static final String DEFAULT_GROUP_ID; static final int MAX_WEIGHT_VALUE; static final int MIN_WEIGHT_VALUE; static final int DEFAULT_WEIGHT_VALUE; }### Answer: @Test public void testFixWeight() { Assert.assertEquals(ServiceGroups.DEFAULT_WEIGHT_VALUE, ServiceGroups.fixWeight(null)); Assert.assertEquals(ServiceGroups.MIN_WEIGHT_VALUE, ServiceGroups.fixWeight(ServiceGroups.MIN_WEIGHT_VALUE)); Assert.assertEquals(ServiceGroups.MAX_WEIGHT_VALUE, ServiceGroups.fixWeight(ServiceGroups.MAX_WEIGHT_VALUE)); Assert.assertEquals(ServiceGroups.MIN_WEIGHT_VALUE + 1, ServiceGroups.fixWeight(ServiceGroups.MIN_WEIGHT_VALUE + 1)); Assert.assertEquals(ServiceGroups.MAX_WEIGHT_VALUE - 1, ServiceGroups.fixWeight(ServiceGroups.MAX_WEIGHT_VALUE - 1)); Assert.assertEquals(ServiceGroups.DEFAULT_WEIGHT_VALUE, ServiceGroups.fixWeight(ServiceGroups.MIN_WEIGHT_VALUE - 1)); Assert.assertEquals(ServiceGroups.MAX_WEIGHT_VALUE, ServiceGroups.fixWeight(ServiceGroups.MAX_WEIGHT_VALUE + 1)); }
### Question: ArtemisDiscoveryHttpClient extends ArtemisHttpClient { public List<Service> getServices(final List<DiscoveryConfig> discoveryConfigs) { Preconditions.checkArgument(!CollectionUtils.isEmpty(discoveryConfigs), "discoveryConfigs should not be null or empty"); final LookupRequest request = new LookupRequest(discoveryConfigs, DeploymentConfig.regionId(), DeploymentConfig.zoneId()); final LookupResponse response = this.request(RestPaths.DISCOVERY_LOOKUP_FULL_PATH, request, LookupResponse.class); ResponseStatus status = response.getResponseStatus(); logEvent(status, "discovery", "lookup"); if (ResponseStatusUtil.isSuccess(status)) return response.getServices(); throw new RuntimeException("lookup services failed. " + status); } ArtemisDiscoveryHttpClient(final ArtemisClientConfig config); Service getService(final DiscoveryConfig discoveryConfig); List<Service> getServices(final List<DiscoveryConfig> discoveryConfigs); }### Answer: @Test public void testGetServices() { final String serviceId = Services.newServiceId(); final List<String> serviceIds = Lists.newArrayList(serviceId, ArtemisClientConstants.RegistryService.Net.serviceKey); final List<DiscoveryConfig> discoveryConfigs = Lists.newArrayList(new DiscoveryConfig(serviceId), new DiscoveryConfig(ArtemisClientConstants.RegistryService.Net.serviceKey)); final List<Service> services = _client.getServices(discoveryConfigs); Assert.assertEquals(discoveryConfigs.size(), services.size()); for (final Service service : services) { Assert.assertTrue(serviceIds.contains(service.getServiceId())); if (ArtemisClientConstants.RegistryService.Net.serviceKey .equals(service.getServiceId())) { Assert.assertTrue(service.getInstances().size() > 0); } else { Assert.assertTrue((service.getInstances() == null) \|\| (service.getInstances().size() == 0)); } } }
### Question: ServiceDiscovery { protected void reload(DiscoveryConfig... configs) { reload(Lists.newArrayList(configs)); } ServiceDiscovery(final ServiceRepository serviceRepository, final ArtemisClientConfig config); void registerDiscoveryConfig(DiscoveryConfig config); Service getService(DiscoveryConfig config); }### Answer: @Test public void testReload() throws Exception { final ServiceRepository serviceRepository = new ServiceRepository(ArtemisClientConstants.DiscoveryClientConfig); final List<Service> services = Lists.newArrayList(); Assert.assertEquals(0, services.size()); Set<String> serviceKeys = Sets.newHashSet(ArtemisClientConstants.RegistryService.Net.serviceKey, ArtemisClientConstants.RegistryService.Java.serviceKey); Map<String, ServiceChangeListener> serviceChangeListeners = Maps.newHashMap(); for (String serviceKey : serviceKeys) { DefaultServiceChangeListener listener = new DefaultServiceChangeListener(); DiscoveryConfig discoveryConfig = new DiscoveryConfig(serviceKey); serviceChangeListeners.put(serviceKey, listener); serviceRepository.registerServiceChangeListener(discoveryConfig, listener); serviceRepository.serviceDiscovery.reload(discoveryConfig); Assert.assertTrue(listener.getServiceChangeEvents().size() >= 1); for (ServiceChangeEvent event : listener.getServiceChangeEvents()) { Assert.assertEquals(InstanceChange.ChangeType.RELOAD, event.changeType()); Assert.assertEquals(serviceKey, event.changedService().getServiceId()); } } }
### Question: BtpRuntimeException extends RuntimeException { public BtpError toBtpError(long requestId) { return toBtpError(requestId, new BtpSubProtocols()); } BtpRuntimeException(); BtpRuntimeException(BtpErrorCode code, String message); BtpRuntimeException(BtpErrorCode code, String message, Throwable cause); BtpRuntimeException(Throwable cause); BtpErrorCode getCode(); Instant getTriggeredAt(); BtpError toBtpError(long requestId); BtpError toBtpError(long requestId, BtpSubProtocols subProtocols); }### Answer: @Test public void toBtpError() { final BtpRuntimeException exception = new BtpRuntimeException(BtpErrorCode.F00_NotAcceptedError, ERROR_MESSAGE); final BtpError error = exception.toBtpError(REQUEST_ID); assertThat(error.getErrorCode()).isEqualTo(BtpErrorCode.F00_NotAcceptedError); assertThat(error.getTriggeredAt()).isEqualTo(exception.getTriggeredAt()); assertThat(error.getErrorData().length).isEqualTo(0); }
### Question: LinkSettingsUtils { public static Map<String, Object> flattenSettings(Map<String, Object> settings) { return flattenSettings("", settings); } static Map<String, Object> flattenSettings(Map<String, Object> settings); static Optional<IlpOverHttpLinkSettings.AuthType> getIncomingAuthType(Map<String, Object> customSettings); static Optional<IlpOverHttpLinkSettings.AuthType> getOutgoingAuthType(Map<String, Object> customSettings); static void validate(AuthenticatedLinkSettings linkSettings); }### Answer: @Test public void flattenSettingsAlreadyFlattened() { assertThat(LinkSettingsUtils.flattenSettings(flattenedSettings)).isEqualTo(flattenedSettings); } @Test public void flattenSettings() { Map<String, Object> grandsonSettings = ImmutableMap.of("name", "fizz", "age", 15); Map<String, Object> grandDaughterSettings = ImmutableMap.of("name", "buzz", "age", 20); Map<String, Object> sonSettings = ImmutableMap.of("name", "bar", "age", 50, "grandson", grandsonSettings, "granddaughter", grandDaughterSettings); Map<String, Object> parentSettings = ImmutableMap.of("name", "foo", "age", 100, "son", sonSettings); Map<String, Object> settings = ImmutableMap.of("parent", parentSettings); assertThat(LinkSettingsUtils.flattenSettings(settings)).isEqualTo(flattenedSettings); }
### Question: JwtHs256BearerTokenSupplier implements BearerTokenSupplier { @Override public String get() { try { return this.ilpOverHttpAuthTokens.get(outgoingLinkSettings.jwtAuthSettings().get().tokenSubject()); } catch (ExecutionException e) { throw new RuntimeException(e); } } JwtHs256BearerTokenSupplier( final SharedSecretBytesSupplier sharedSecretBytesSupplier, final OutgoingLinkSettings outgoingLinkSettings ); @Override String get(); }### Answer: @Test public void checkCaching() { OutgoingLinkSettings linkSettings = createOutgoingSettings(Duration.ofMinutes(5)); JwtHs256BearerTokenSupplier tokenSupplier = new JwtHs256BearerTokenSupplier(secretBytesSupplier, linkSettings); tokenSupplier.get(); tokenSupplier.get(); verify(secretBytesSupplier).get(); } @Test public void checkCachingWithCachingDisabled() { OutgoingLinkSettings linkSettings = createOutgoingSettings(Duration.ofMinutes(0)); JwtHs256BearerTokenSupplier tokenSupplier = new JwtHs256BearerTokenSupplier(secretBytesSupplier, linkSettings); tokenSupplier.get(); tokenSupplier.get(); verify(secretBytesSupplier, times(2)).get(); } @Test public void checkCacheExpiry() throws Exception { OutgoingLinkSettings linkSettings = createOutgoingSettings(Duration.ofMillis(2)); JwtHs256BearerTokenSupplier tokenSupplier = new JwtHs256BearerTokenSupplier(secretBytesSupplier, linkSettings); tokenSupplier.get(); Thread.sleep(3); tokenSupplier.get(); verify(secretBytesSupplier, times(2)).get(); }
### Question: AsnIldcpResponsePacketDataCodec extends AsnSequenceCodec<IldcpResponsePacket> { @Override public IldcpResponsePacket decode() { final IldcpResponse ildcpResponse; try { ildcpResponse = IldcpCodecContextFactory.oer() .read(IldcpResponse.class, new ByteArrayInputStream(getValueAt(1))); } catch (IOException e) { throw new IldcpCodecException(e.getMessage(), e); } return IldcpResponsePacket.builder() .fulfillment(getValueAt(0)) .ildcpResponse(ildcpResponse) .build(); } AsnIldcpResponsePacketDataCodec(); @Override IldcpResponsePacket decode(); @Override void encode(IldcpResponsePacket value); }### Answer: @Test public void decode() throws IOException { final ByteArrayOutputStream os = new ByteArrayOutputStream(); IldcpCodecContextFactory.oer().write(packet, os); final IldcpResponsePacket actual = IldcpCodecContextFactory.oer() .read(IldcpResponsePacket.class, new ByteArrayInputStream(os.toByteArray())); assertThat(actual).isEqualTo(packet); }
### Question: DateUtils { public static Instant now() { return Instant.now().truncatedTo(ChronoUnit.MILLIS); } static Instant now(); }### Answer: @Test public void now() { for (int i = 0; i < 100; i++) { long micros = DateUtils.now().get(ChronoField.MICRO_OF_SECOND); assertThat(micros % 1000).isEqualTo(0); } }
### Question: InterledgerRustNodeClient { public BigDecimal getBalance(String accountName) throws SpspClientException { return execute(requestBuilder() .url( baseUrl.newBuilder().addPathSegment("accounts").addPathSegment(accountName).addPathSegment("balance").build() ) .get() .build(), BalanceResponse.class) .getBalance(); } @Deprecated InterledgerRustNodeClient(OkHttpClient okHttpClient, String authToken, String baseUrl); InterledgerRustNodeClient( final OkHttpClient okHttpClient, final String authToken, final HttpUrl baseUrl ); RustNodeAccount createAccount(RustNodeAccount rustNodeAccount); BigDecimal getBalance(String accountName); static final MediaType JSON; }### Answer: @Test public void getBalance() { String bigBalance = "12345678901234567890.11111"; String testClient = "testClient"; stubFor(get(urlEqualTo("/accounts/" + testClient + "/balance")) .withHeader("Authorization", equalTo("Bearer passwordin")) .willReturn(aResponse() .withStatus(200) .withBody("{\"balance\":\"" + bigBalance + "\"}") )); BigDecimal response = client.getBalance(testClient); assertThat(response).isEqualTo(new BigDecimal(bigBalance)); }
### Question: IldcpResponsePacketMapper { public final T map(final InterledgerResponsePacket responsePacket) { Objects.requireNonNull(responsePacket); if (InterledgerFulfillPacket.class.isAssignableFrom(responsePacket.getClass())) { return mapFulfillPacket((IldcpResponsePacket) responsePacket); } else if (InterledgerRejectPacket.class.isAssignableFrom(responsePacket.getClass())) { return mapRejectPacket((InterledgerRejectPacket) responsePacket); } else { throw new RuntimeException( String.format("Unsupported IldcpResponsePacket Type: %s", responsePacket.getClass())); } } final T map(final InterledgerResponsePacket responsePacket); }### Answer: @Test public void mapFulfill() { ResponseWrapper wrapper = new ResponseWrapperMapper().map(fulfillPacket); assertThat(wrapper.get()).isEqualTo(fulfillPacket); } @Test public void mapReject() { ResponseWrapper wrapper = new ResponseWrapperMapper().map(rejectPacket); assertThat(wrapper.get()).isEqualTo(rejectPacket); } @Test public void cannotMap() { expectedException.expect(RuntimeException.class); expectedException.expectMessage("Unsupported IldcpResponsePacket Type: " + "class org.interledger.ildcp.InterledgerShampooPacketBuilder$ImmutableInterledgerShampooPacket"); new ResponseWrapperMapper().map(shampooPacket); }
### Question: AsnIldcpPacketCodec extends AsnSequenceCodec<T> { protected void onTypeIdChanged(int typeId) { switch (typeId) { case IldcpPacketTypes.REQUEST: setCodecAt(1, new AsnOpenTypeCodec<>(new AsnIldcpRequestPacketDataCodec())); return; case IldcpPacketTypes.RESPONSE: setCodecAt(1, new AsnOpenTypeCodec<>(new AsnIldcpResponsePacketDataCodec())); return; default: throw new CodecException(format("Unknown IL-DCP packet type code: %s", typeId)); } } AsnIldcpPacketCodec(); @Override T decode(); @Override void encode(T value); }### Answer: @Test(expected = CodecException.class) public void onTypeIdChangedToUnsupported() { try { codec.onTypeIdChanged((short) 50); Assert.fail(); } catch (CodecException e) { assertThat(e.getMessage()).isEqualTo("Unknown IL-DCP packet type code: 50"); throw e; } }
### Question: AimdCongestionController implements CongestionController { @Override public boolean hasInFlight() { return is(this.amountInFlight.get()).greaterThan(UnsignedLong.ZERO); } AimdCongestionController(); AimdCongestionController( final UnsignedLong startAmount, final UnsignedLong increaseAmount, final BigDecimal decreaseFactor, final CodecContext streamCodecContext ); @Override UnsignedLong getMaxAmount(); @Override void prepare(final UnsignedLong amount); @Override void fulfill(final UnsignedLong prepareAmount); @Override void reject(final UnsignedLong prepareAmount, final InterledgerRejectPacket rejectPacket); @Override CongestionState getCongestionState(); void setCongestionState(final CongestionState congestionState); @Override Optional<UnsignedLong> getMaxPacketAmount(); void setMaxPacketAmount(final UnsignedLong maxPacketAmount); void setMaxPacketAmount(final Optional<UnsignedLong> maxPacketAmount); @Override boolean hasInFlight(); }### Answer: @Test public void hasInFlight() { controller.prepare(UnsignedLong.ONE); assertThat(controller.hasInFlight()).isTrue(); }
### Question: AsnIldcpRequestPacketDataCodec extends AsnSequenceCodec<IldcpRequestPacket> { @Override public void encode(IldcpRequestPacket value) { setValueAt(0, value.getAmount()); setValueAt(1, value.getExpiresAt()); setValueAt(2, value.getExecutionCondition()); setValueAt(3, value.getDestination()); setValueAt(4, value.getData()); } AsnIldcpRequestPacketDataCodec(); @Override IldcpRequestPacket decode(); @Override void encode(IldcpRequestPacket value); }### Answer: @Test public void encode() { codec.encode(packet); assertThat((UnsignedLong) codec.getValueAt(0)).isEqualTo(UnsignedLong.ZERO); assertThat((Instant) codec.getValueAt(1)).isEqualTo(NOW); assertThat((InterledgerCondition) codec.getValueAt(2)) .isEqualTo(IldcpRequestPacket.EXECUTION_CONDITION); assertThat((InterledgerAddress) codec.getValueAt(3)).isEqualTo(IldcpRequestPacket.PEER_DOT_CONFIG); assertThat((byte[]) codec.getValueAt(4)).isEqualTo(new byte[0]); }
### Question: StreamConnectionManager { public StreamConnection openConnection(final StreamConnectionId streamConnectionId) { Objects.requireNonNull(streamConnectionId); return connections.computeIfAbsent(streamConnectionId, StreamConnection::new); } StreamConnection openConnection(final StreamConnectionId streamConnectionId); Optional<StreamConnection> closeConnection(final StreamConnectionId streamConnectionId); }### Answer: @Test public void openConnection() { StreamConnectionId streamConnectionId = StreamConnectionId.of("foo"); final StreamConnection streamConnection = streamConnectionManager .openConnection(streamConnectionId); assertThat(streamConnectionManager.openConnection(streamConnectionId)).isEqualTo(streamConnection); assertThat(streamConnectionManager.openConnection(streamConnectionId)).isEqualTo(streamConnection); }
### Question: StreamConnectionManager { public Optional<StreamConnection> closeConnection(final StreamConnectionId streamConnectionId) { Objects.requireNonNull(streamConnectionId); return Optional.ofNullable(connections.get(streamConnectionId)) .map(connectionToClose -> { connectionToClose.closeConnection(); return connectionToClose; }); } StreamConnection openConnection(final StreamConnectionId streamConnectionId); Optional<StreamConnection> closeConnection(final StreamConnectionId streamConnectionId); }### Answer: @Test public void closeConnection() { StreamConnectionId streamConnectionId = StreamConnectionId.of("foo"); final StreamConnection streamConnection = streamConnectionManager .openConnection(streamConnectionId); assertThat(streamConnectionManager.closeConnection(streamConnectionId)).get().isEqualTo(streamConnection); assertThat(streamConnectionManager.closeConnection(streamConnectionId)).get().isEqualTo(streamConnection); }
### Question: AsnIldcpRequestPacketDataCodec extends AsnSequenceCodec<IldcpRequestPacket> { @Override public IldcpRequestPacket decode() { return IldcpRequestPacket.builder() .amount(getValueAt(0)) .expiresAt(getValueAt(1)) .build(); } AsnIldcpRequestPacketDataCodec(); @Override IldcpRequestPacket decode(); @Override void encode(IldcpRequestPacket value); }### Answer: @Test public void decode() throws IOException { final ByteArrayOutputStream os = new ByteArrayOutputStream(); IldcpCodecContextFactory.oer().write(packet, os); final IldcpRequestPacket actual = IldcpCodecContextFactory.oer() .read(IldcpRequestPacket.class, new ByteArrayInputStream(os.toByteArray())); assertThat(actual).isEqualTo(packet); }
### Question: AesGcmStreamEncryptionService implements StreamEncryptionService { @VisibleForTesting byte[] encryptWithIv(final SharedSecret sharedSecret, final byte[] plainText, final byte[] iv) throws EncryptionException { Objects.requireNonNull(sharedSecret); Objects.requireNonNull(plainText); Objects.requireNonNull(iv); if (this.encryptionMode == EncryptionMode.ENCRYPT_NON_STANDARD) { return this.nonStandardModeEncryptWithIv(sharedSecret, plainText, iv); } else { return this.standardModeEncryptWithIv(sharedSecret, plainText, iv); } } AesGcmStreamEncryptionService(); AesGcmStreamEncryptionService(final EncryptionMode encryptionMode); @Override byte[] encrypt(final SharedSecret sharedSecret, final byte[] plainText); @Override byte[] decrypt(final SharedSecret sharedSecret, final byte[] cipherMessage); }### Answer: @Test public void testEncryptToSameRustJs() { byte[] encryptedValue = streamEncryptionService.encryptWithIv(SHARED_SECRET, PLAINTEXT, NONCE_IV); assertThat(encryptedValue).isEqualTo(CIPHERTEXT); }
### Question: AesGcmStreamEncryptionService implements StreamEncryptionService { @Override public byte[] decrypt(final SharedSecret sharedSecret, final byte[] cipherMessage) { Objects.requireNonNull(sharedSecret); Objects.requireNonNull(cipherMessage); if (this.encryptionMode == EncryptionMode.ENCRYPT_NON_STANDARD) { try { return this.nonStandardModeDecrypt(sharedSecret, cipherMessage); } catch (EncryptionException e) { logger.warn( "Unable to decrypt payload in {} mode. Attempting {} mode as a fallback.", EncryptionMode.ENCRYPT_NON_STANDARD, EncryptionMode.ENCRYPT_STANDARD, e ); return this.standardModeDecrypt(sharedSecret, cipherMessage); } } else { try { return this.standardModeDecrypt(sharedSecret, cipherMessage); } catch (EncryptionException e) { logger.warn( "Unable to decrypt payload in {} mode. Attempting {} mode as a fallback.", EncryptionMode.ENCRYPT_STANDARD, EncryptionMode.ENCRYPT_NON_STANDARD, e ); return this.nonStandardModeDecrypt(sharedSecret, cipherMessage); } } } AesGcmStreamEncryptionService(); AesGcmStreamEncryptionService(final EncryptionMode encryptionMode); @Override byte[] encrypt(final SharedSecret sharedSecret, final byte[] plainText); @Override byte[] decrypt(final SharedSecret sharedSecret, final byte[] cipherMessage); }### Answer: @Test public void testDecryptToSameAsRustJs() { byte[] decryptedValue = streamEncryptionService.decrypt(SHARED_SECRET, CIPHERTEXT); assertThat(decryptedValue).isEqualTo(PLAINTEXT); } @Test public void testDecryptToSameAsRustJsInStandardMode() { this.streamEncryptionService = new AesGcmStreamEncryptionService(EncryptionMode.ENCRYPT_STANDARD); byte[] decryptedValue = streamEncryptionService.decrypt(SHARED_SECRET, CIPHERTEXT); assertThat(decryptedValue).isEqualTo(PLAINTEXT); }
### Question: StreamConnection implements Closeable { public StreamConnectionId getStreamConnectionId() { return streamConnectionId; } StreamConnection(final InterledgerAddress receiverAddress, final SharedSecret sharedSecret); StreamConnection(final StreamConnectionId streamConnectionId); UnsignedLong nextSequence(); Instant getCreationDateTime(); void transitionConnectionState(); StreamConnectionState getConnectionState(); StreamConnectionId getStreamConnectionId(); void closeConnection(); boolean isClosed(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override void close(); static final UnsignedLong MAX_FRAMES_PER_CONNECTION; }### Answer: @Test public void testConstructorWithAddressAndSecret() { streamConnection = new StreamConnection(InterledgerAddress.of("example.foo"), SharedSecret.of(new byte[32])); assertThat(streamConnection.getStreamConnectionId()) .isEqualTo(StreamConnectionId.of("246307596a10c1ba057f56cd6d588ed0d11cf3f8817c937265e93950af53751f")); } @Test public void testStreamConnectionId() { StreamConnectionId streamConnectionId = StreamConnectionId.of("foo"); assertThat(new StreamConnection(streamConnectionId).getStreamConnectionId()).isEqualTo(streamConnectionId); }
### Question: StreamConnection implements Closeable { public UnsignedLong nextSequence() throws StreamConnectionClosedException { final UnsignedLong nextSequence = sequence.getAndUpdate(currentSequence -> currentSequence.plus(UnsignedLong.ONE)); if (sequenceIsSafeForSingleSharedSecret(nextSequence)) { return nextSequence; } else { this.closeConnection(); throw new StreamConnectionClosedException(streamConnectionId); } } StreamConnection(final InterledgerAddress receiverAddress, final SharedSecret sharedSecret); StreamConnection(final StreamConnectionId streamConnectionId); UnsignedLong nextSequence(); Instant getCreationDateTime(); void transitionConnectionState(); StreamConnectionState getConnectionState(); StreamConnectionId getStreamConnectionId(); void closeConnection(); boolean isClosed(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override void close(); static final UnsignedLong MAX_FRAMES_PER_CONNECTION; }### Answer: @Test public void nextSequence() throws StreamConnectionClosedException { assertThat(streamConnection.nextSequence()).isEqualTo(UnsignedLong.ONE); assertThat(streamConnection.nextSequence()).isEqualTo(UnsignedLong.valueOf(2L)); assertThat(streamConnection.nextSequence()).isEqualTo(UnsignedLong.valueOf(3L)); assertThat(streamConnection.nextSequence()).isEqualTo(UnsignedLong.valueOf(4L)); } @Test public void nextSequenceMultiThreaded() throws StreamConnectionClosedException { final List<CompletableFuture<UnsignedLong>> allFutures = Lists.newArrayList(); final int numRepetitions = 50000; final ExecutorService executorService = Executors.newFixedThreadPool(10); for (int i = 0; i < numRepetitions; i++) { allFutures.add( CompletableFuture.supplyAsync(() -> { try { UnsignedLong sequence = streamConnection.nextSequence(); return sequence; } catch (StreamConnectionClosedException e) { throw new RuntimeException(e); } }, executorService) ); } CompletableFuture.allOf(allFutures.toArray(new CompletableFuture[0])).join(); assertThat(streamConnection.nextSequence().longValue()).isEqualTo(numRepetitions + 1); }
### Question: StreamConnection implements Closeable { public void transitionConnectionState() { this.connectionState.updateAndGet(streamConnectionState -> { switch (streamConnectionState) { case AVAILABLE: { return StreamConnectionState.OPEN; } case OPEN: case CLOSED: default: { return StreamConnectionState.CLOSED; } } }); } StreamConnection(final InterledgerAddress receiverAddress, final SharedSecret sharedSecret); StreamConnection(final StreamConnectionId streamConnectionId); UnsignedLong nextSequence(); Instant getCreationDateTime(); void transitionConnectionState(); StreamConnectionState getConnectionState(); StreamConnectionId getStreamConnectionId(); void closeConnection(); boolean isClosed(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override void close(); static final UnsignedLong MAX_FRAMES_PER_CONNECTION; }### Answer: @Test public void transitionConnectionState() { assertThat(streamConnection.isClosed()).isFalse(); assertThat(streamConnection.getConnectionState()).isEqualTo(StreamConnectionState.AVAILABLE); assertThat(streamConnection.getConnectionState()).isEqualTo(StreamConnectionState.AVAILABLE); streamConnection.transitionConnectionState(); assertThat(streamConnection.isClosed()).isFalse(); assertThat(streamConnection.getConnectionState()).isEqualTo(StreamConnectionState.OPEN); assertThat(streamConnection.getConnectionState()).isEqualTo(StreamConnectionState.OPEN); streamConnection.transitionConnectionState(); assertThat(streamConnection.isClosed()).isTrue(); assertThat(streamConnection.getConnectionState()).isEqualTo(StreamConnectionState.CLOSED); assertThat(streamConnection.isClosed()).isTrue(); assertThat(streamConnection.getConnectionState()).isEqualTo(StreamConnectionState.CLOSED); streamConnection.transitionConnectionState(); streamConnection.transitionConnectionState(); streamConnection.transitionConnectionState(); assertThat(streamConnection.getConnectionState()).isEqualTo(StreamConnectionState.CLOSED); assertThat(streamConnection.getConnectionState()).isEqualTo(StreamConnectionState.CLOSED); assertThat(streamConnection.isClosed()).isTrue(); }
### Question: StreamConnection implements Closeable { public Instant getCreationDateTime() { return creationDateTime; } StreamConnection(final InterledgerAddress receiverAddress, final SharedSecret sharedSecret); StreamConnection(final StreamConnectionId streamConnectionId); UnsignedLong nextSequence(); Instant getCreationDateTime(); void transitionConnectionState(); StreamConnectionState getConnectionState(); StreamConnectionId getStreamConnectionId(); void closeConnection(); boolean isClosed(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override void close(); static final UnsignedLong MAX_FRAMES_PER_CONNECTION; }### Answer: @Test public void getCreationDateTime() { assertThat(streamConnection.getCreationDateTime()).isNotNull(); assertThat(streamConnection.getCreationDateTime()).isBefore(DateUtils.now().plusSeconds(1)); }
### Question: StreamConnection implements Closeable { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null \|\| getClass() != obj.getClass()) { return false; } StreamConnection that = (StreamConnection) obj; return streamConnectionId.equals(that.streamConnectionId); } StreamConnection(final InterledgerAddress receiverAddress, final SharedSecret sharedSecret); StreamConnection(final StreamConnectionId streamConnectionId); UnsignedLong nextSequence(); Instant getCreationDateTime(); void transitionConnectionState(); StreamConnectionState getConnectionState(); StreamConnectionId getStreamConnectionId(); void closeConnection(); boolean isClosed(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override void close(); static final UnsignedLong MAX_FRAMES_PER_CONNECTION; }### Answer: @Test public void testEquals() { assertThat(streamConnection.equals(null)).isFalse(); assertThat(streamConnection.equals(streamConnection)).isTrue(); StreamConnection identicalStreamConnection = new StreamConnection(StreamConnectionId.of("foo")); assertThat(streamConnection.equals(identicalStreamConnection)).isTrue(); assertThat(identicalStreamConnection.equals(streamConnection)).isTrue(); StreamConnection nonIdenticalStreamConnection = new StreamConnection(StreamConnectionId.of("foo1")); assertThat(streamConnection.equals(nonIdenticalStreamConnection)).isFalse(); assertThat(nonIdenticalStreamConnection.equals(streamConnection)).isFalse(); }
### Question: StreamConnection implements Closeable { @Override public int hashCode() { return streamConnectionId.hashCode(); } StreamConnection(final InterledgerAddress receiverAddress, final SharedSecret sharedSecret); StreamConnection(final StreamConnectionId streamConnectionId); UnsignedLong nextSequence(); Instant getCreationDateTime(); void transitionConnectionState(); StreamConnectionState getConnectionState(); StreamConnectionId getStreamConnectionId(); void closeConnection(); boolean isClosed(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override void close(); static final UnsignedLong MAX_FRAMES_PER_CONNECTION; }### Answer: @Test public void testHashCode() { StreamConnection identicalStreamConnection = new StreamConnection(StreamConnectionId.of("foo")); assertThat(streamConnection.hashCode()).isEqualTo(identicalStreamConnection.hashCode()); StreamConnection nonIdenticalStreamConnection = new StreamConnection(StreamConnectionId.of("foo1")); assertThat(streamConnection.hashCode()).isNotEqualTo(nonIdenticalStreamConnection.hashCode()); }
### Question: StreamConnection implements Closeable { @Override public String toString() { return new StringJoiner(", ", StreamConnection.class.getSimpleName() + "[", "]") .add("creationDateTime=" + creationDateTime) .add("streamConnectionId=" + streamConnectionId) .add("sequence=" + sequence) .add("connectionState=" + connectionState) .toString(); } StreamConnection(final InterledgerAddress receiverAddress, final SharedSecret sharedSecret); StreamConnection(final StreamConnectionId streamConnectionId); UnsignedLong nextSequence(); Instant getCreationDateTime(); void transitionConnectionState(); StreamConnectionState getConnectionState(); StreamConnectionId getStreamConnectionId(); void closeConnection(); boolean isClosed(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override void close(); static final UnsignedLong MAX_FRAMES_PER_CONNECTION; }### Answer: @Test public void testToString() { final String matchingSerializedRegex = "StreamConnection\\[" + "creationDateTime=[0-9]{4}\\-[0-9]{2}\\-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}.\\d+Z, " + "streamConnectionId=\\S+ sequence=\\d+, connectionState=[A-Z]+]"; final String serializedStreamConnection = streamConnection.toString(); assertThat(serializedStreamConnection.matches(matchingSerializedRegex)).isTrue(); }
### Question: StreamUtils { public static InterledgerFulfillment generatedFulfillableFulfillment( final SharedSecret sharedSecret, final byte[] data ) { Objects.requireNonNull(sharedSecret); Objects.requireNonNull(data); final SecretKey secretKey = new SecretKeySpec(sharedSecret.key(), HMAC_SHA256_ALG_NAME); final byte[] hmacKey = Hashing.hmacSha256(secretKey).hashBytes(ILP_STREAM_FULFILLMENT).asBytes(); final SecretKey hmacSecretKey = new SecretKeySpec(hmacKey, HMAC_SHA256_ALG_NAME); final byte[] fulfillmentBytes = Hashing.hmacSha256(hmacSecretKey).hashBytes(data).asBytes(); return InterledgerFulfillment.of(fulfillmentBytes); } static InterledgerCondition unfulfillableCondition(); static InterledgerFulfillment generatedFulfillableFulfillment( final SharedSecret sharedSecret, final byte[] data ); static UnsignedLong min(final UnsignedLong value1, final UnsignedLong value2); static UnsignedLong max(final UnsignedLong value1, final UnsignedLong value2); }### Answer: @Test public void generatedFulfillableFulfillment() { InterledgerFulfillment fulfillment = StreamUtils.generatedFulfillableFulfillment(SHARED_SECRET, DATA); assertThat(fulfillment.getPreimage()).isEqualTo(FULFILLMENT); assertThat(fulfillment).isEqualTo(InterledgerFulfillment.of(FULFILLMENT)); }
### Question: StreamUtils { public static UnsignedLong min(final UnsignedLong value1, final UnsignedLong value2) { Objects.requireNonNull(value1); Objects.requireNonNull(value2); if (is(value1).lessThan(value2)) { return value1; } else { return value2; } } static InterledgerCondition unfulfillableCondition(); static InterledgerFulfillment generatedFulfillableFulfillment( final SharedSecret sharedSecret, final byte[] data ); static UnsignedLong min(final UnsignedLong value1, final UnsignedLong value2); static UnsignedLong max(final UnsignedLong value1, final UnsignedLong value2); }### Answer: @Test(expected = NullPointerException.class) public void minWithNullFirst() { try { StreamUtils.min(null, UnsignedLong.ONE); fail(); } catch (NullPointerException e) { assertThat(e.getMessage()).isNull(); throw e; } } @Test(expected = NullPointerException.class) public void minWithNullSecond() { try { StreamUtils.min(UnsignedLong.ONE, null); fail(); } catch (NullPointerException e) { assertThat(e.getMessage()).isNull(); throw e; } } @Test public void minTests() { assertThat(StreamUtils.min(UnsignedLong.ZERO, UnsignedLong.ZERO)).isEqualTo(UnsignedLong.ZERO); assertThat(StreamUtils.min(UnsignedLong.ONE, UnsignedLong.ZERO)).isEqualTo(UnsignedLong.ZERO); assertThat(StreamUtils.min(UnsignedLong.ZERO, UnsignedLong.ONE)).isEqualTo(UnsignedLong.ZERO); assertThat(StreamUtils.min(UnsignedLong.MAX_VALUE, UnsignedLong.ZERO)).isEqualTo(UnsignedLong.ZERO); assertThat(StreamUtils.min(UnsignedLong.ZERO, UnsignedLong.MAX_VALUE)).isEqualTo(UnsignedLong.ZERO); assertThat(StreamUtils.min(UnsignedLong.ONE, UnsignedLong.MAX_VALUE)).isEqualTo(UnsignedLong.ONE); assertThat(StreamUtils.min(UnsignedLong.MAX_VALUE, UnsignedLong.ONE)).isEqualTo(UnsignedLong.ONE); }
### Question: StreamUtils { public static UnsignedLong max(final UnsignedLong value1, final UnsignedLong value2) { Objects.requireNonNull(value1); Objects.requireNonNull(value2); if (is(value1).greaterThan(value2)) { return value1; } else { return value2; } } static InterledgerCondition unfulfillableCondition(); static InterledgerFulfillment generatedFulfillableFulfillment( final SharedSecret sharedSecret, final byte[] data ); static UnsignedLong min(final UnsignedLong value1, final UnsignedLong value2); static UnsignedLong max(final UnsignedLong value1, final UnsignedLong value2); }### Answer: @Test public void maxTests() { assertThat(StreamUtils.max(UnsignedLong.ZERO, UnsignedLong.ZERO)).isEqualTo(UnsignedLong.ZERO); assertThat(StreamUtils.max(UnsignedLong.ONE, UnsignedLong.ZERO)).isEqualTo(UnsignedLong.ONE); assertThat(StreamUtils.max(UnsignedLong.ZERO, UnsignedLong.ONE)).isEqualTo(UnsignedLong.ONE); assertThat(StreamUtils.max(UnsignedLong.MAX_VALUE, UnsignedLong.ZERO)).isEqualTo(UnsignedLong.MAX_VALUE); assertThat(StreamUtils.max(UnsignedLong.ZERO, UnsignedLong.MAX_VALUE)).isEqualTo(UnsignedLong.MAX_VALUE); assertThat(StreamUtils.max(UnsignedLong.ONE, UnsignedLong.MAX_VALUE)).isEqualTo(UnsignedLong.MAX_VALUE); assertThat(StreamUtils.max(UnsignedLong.MAX_VALUE, UnsignedLong.ONE)).isEqualTo(UnsignedLong.MAX_VALUE); }
### Question: StreamUtils { public static InterledgerCondition unfulfillableCondition() { return InterledgerCondition.of(Random.randBytes(32)); } static InterledgerCondition unfulfillableCondition(); static InterledgerFulfillment generatedFulfillableFulfillment( final SharedSecret sharedSecret, final byte[] data ); static UnsignedLong min(final UnsignedLong value1, final UnsignedLong value2); static UnsignedLong max(final UnsignedLong value1, final UnsignedLong value2); }### Answer: @Test public void unfulfillableCondition() { assertThat(StreamUtils.unfulfillableCondition()).isNotNull(); assertThat(StreamUtils.unfulfillableCondition()).isNotEqualTo(InterledgerCondition.of(new byte[32])); }
### Question: NoOpExchangeRateCalculator implements ExchangeRateCalculator { @Override public UnsignedLong calculateMinAmountToAccept( final UnsignedLong sendAmount, final Denomination sendAmountDenomination ) { Objects.requireNonNull(sendAmount); Objects.requireNonNull(sendAmountDenomination); return UnsignedLong.ZERO; } @Override UnsignedLong calculateAmountToSend(UnsignedLong amountToSend, Denomination amountToSendDenomination, Denomination receiverDenomination); @Override UnsignedLong calculateMinAmountToAccept( final UnsignedLong sendAmount, final Denomination sendAmountDenomination ); }### Answer: @Test public void calculateMinAmountToAcceptInReceiverAmountMode() { ExchangeRateCalculator calc = new NoOpExchangeRateCalculator(); assertThat(calc.calculateMinAmountToAccept(UnsignedLong.ONE, Denominations.USD, Denominations.EUR)) .isEqualTo(UnsignedLong.ZERO); } @Test public void calculateMinAmountToAcceptInSenderAmountMode() { ExchangeRateCalculator calc = new NoOpExchangeRateCalculator(); assertThat(calc.calculateMinAmountToAccept(UnsignedLong.ONE, Denominations.USD)) .isEqualTo(UnsignedLong.ZERO); }
### Question: OerLengthSerializer { public static void writeLength(final int length, final OutputStream outputStream) throws IOException { Objects.requireNonNull(outputStream); if (length <= 0) { outputStream.write(0); } else { if (length >= 0 && length < 128) { outputStream.write(length); } else { if (length <= 127) { outputStream.write(length); } else if (length <= 255) { outputStream.write(128 + 1); outputStream.write(length); } else if (length <= 65535) { outputStream.write(128 + 2); outputStream.write((length >> 8)); outputStream.write(length); } else if (length <= 16777215) { outputStream.write(128 + 3); outputStream.write((length >> 16)); outputStream.write((length >> 8)); outputStream.write(length); } else { outputStream.write(128 + 4); outputStream.write((length >> 24)); outputStream.write((length >> 16)); outputStream.write((length >> 8)); outputStream.write(length); } } } } static int readLength(final InputStream inputStream); static void writeLength(final int length, final OutputStream outputStream); }### Answer: @Test public void write() throws Exception { final ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); OerLengthSerializer.writeLength(expectedPayloadLength, outputStream); assertThat(this.asn1OerBytes).isEqualTo(outputStream.toByteArray()); } @Test public void writeNegativeLength() throws IOException { ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); OerLengthSerializer.writeLength(Integer.MIN_VALUE, outputStream); assertThat(BaseEncoding.base16().decode("00")).isEqualTo(outputStream.toByteArray()); outputStream = new ByteArrayOutputStream(); OerLengthSerializer.writeLength(-1, outputStream); assertThat(BaseEncoding.base16().decode("00")).isEqualTo(outputStream.toByteArray()); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.