Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: JarAccessor { static InputStream readEntry(String jarUrl, String entryName) { try { URL url = new URL(convertToJarUrl(jarUrl)); JarURLConnection jarConnection = (JarURLConnection) url.openConnection(); JarFile jarFile = jarConnection.getJarFile(); return jarFile.getInputStream(jarFile.getEntry(entryName)); } catch (IOException e) { LoggingSupport.logErrorMessage(e.getMessage(), e); } return null; } }### Answer: @Test public void testRead() { try { InputStream inputStream = JarAccessor.readEntry(JarAccessorTest.class.getResource(FEATURE_TEST_JAR).toURI().toString(), FEATURE_TEST_XML); assertNotNull(inputStream); } catch (URISyntaxException e) { e.printStackTrace(); fail(); } }
### Question: AdditionalDependencyProvider { static Set<Dependency> readAdditionalDependencies(InputStream additionalDependenciesFile) { Set<Dependency> additionalDependencies = new HashSet<>(); try (Scanner sc = new Scanner(additionalDependenciesFile)) { while (sc.hasNextLine()) { handleDependency(additionalDependencies, sc.nextLine(), additionalDependenciesFile.toString()); } } return additionalDependencies; } }### Answer: @Test public void testDependencyAdder() { InputStream resource = FeaturePluginFilter.class.getResourceAsStream(ADDITIONAL_DEPENDENCIES_FILE); Set<Dependency> dependencies = AdditionalDependencyProvider.readAdditionalDependencies(resource); assertThat(dependencies.size(), equalTo(1)); if (dependencies.size() == 1) { Dependency dependency = dependencies.iterator().next(); assertThat(dependency.getGroupId(), equalTo(GROUP_ID)); assertThat(dependency.getArtifactId(), equalTo(ARTIFACT_ID)); assertThat(dependency.getVersion(), equalTo(VERSION)); } }
### Question: FeaturePluginExtractor { static Set<IFeaturePlugin> extractFeaturePlugins(InputStream featureInputStream) { WorkspaceFeatureModel fmodel = new WorkspaceFeatureModel(new FileWrapper(featureInputStream)); fmodel.load(); Map<String, IFeaturePlugin> map = new HashMap<>(); Arrays.stream(fmodel.getFeature().getPlugins()).forEach(p -> map.put(p.getId(), p)); return new HashSet<>(map.values()); } }### Answer: @Test public void testExtractFeaturePlugins() { Set<IFeaturePlugin> featurePlugins = FeaturePluginExtractor .extractFeaturePlugins(getClass().getResourceAsStream(FEATURE_TEST_XML)); assertThat(featurePlugins.size(), equalTo(1)); if (featurePlugins.size() == 1) { IFeaturePlugin featurePlugin = featurePlugins.iterator().next(); assertThat(featurePlugin.getId(), equalTo(FEATURE_ID)); assertThat(featurePlugin.getVersion(), equalTo(FEATURE_VERSION)); } }
### Question: UpdateSiteAccessor { static String extractRelativeTargetPlatformFeatureJarUrl(InputStream siteInputStream, String urlPrefix) { WorkspaceSiteModel model = new WorkspaceSiteModel(new FileWrapper(siteInputStream)); model.load(); for (ISiteFeature f : model.getSite().getFeatures()) { if (f.getURL().startsWith(urlPrefix)) { return f.getURL(); } } return null; } }### Answer: @Test public void testExctractRelativeUrl() { String jarPath = UpdateSiteAccessor.extractRelativeTargetPlatformFeatureJarUrl(getClass().getResourceAsStream(SITE_TEST_XML), JAR_PREFIX); assertThat(jarPath, equalTo(JAR_PATH)); }
### Question: UpdateSiteAccessor { static String readRelativeTargetPlatformFeatureJarUrl(String siteUrl, String targetJarUrlPrefix, Proxy proxy) { try { URL url = new URL(siteUrl); if (proxy != null) { LoggingSupport.logInfoMessage("Using proxy (" + proxy.address() + ") for getting the targetplatform feature at URL " + siteUrl); } URLConnection connection = proxy != null ? url.openConnection(proxy) : url.openConnection(); InputStream siteInputStream = connection.getInputStream(); return extractRelativeTargetPlatformFeatureJarUrl(siteInputStream, targetJarUrlPrefix); } catch (IOException e) { LoggingSupport.logErrorMessage(e.getMessage(), e); return null; } } }### Answer: @Test public void testReadRelativeUrl() { try { URL resource = getClass().getResource(SITE_TEST_XML); String jarPath = UpdateSiteAccessor.readRelativeTargetPlatformFeatureJarUrl(resource.toURI().toString(), JAR_PREFIX, null); assertThat(jarPath, equalTo(JAR_PATH)); } catch (URISyntaxException e) { fail(e.getMessage()); } }
### Question: PomWriter { static void writePom(File file, String groupId, String artifactId, String version, Set<Dependency> dependencies) { Model model = new Model(); model.setModelVersion(MAVEN_MODEL_VERSION); model.setArtifactId(artifactId); model.setGroupId(groupId); model.setVersion(version); model.setPackaging(PACKAGING_TYPE); model.setDependencies(new ArrayList<>(dependencies)); DefaultModelWriter writer = new DefaultModelWriter(); try { writer.write(file, (Map<String, Object>) null, model); } catch (IOException e) { LoggingSupport.logErrorMessage(e.getMessage(), e); } } }### Answer: @Test public void testPomGeneration() throws IOException { File pomFile = createDestinationFile(); Set<Dependency> dependencies = generateDependencies(); PomWriter.writePom(pomFile, GROUP_ID, ARTIFACT_ID, VERSION, dependencies); Scanner scanner = new Scanner(pomFile); StringWriter writer = new StringWriter(); String generatedFileContent = scanner.useDelimiter(DELIMITER).next(); IOUtils.copy(getClass().getResourceAsStream(POM_CMP_XML), writer); String expectedFileContent = writer.toString(); scanner.close(); assertThat(generatedFileContent.replaceAll("\\s+", ""), equalTo(expectedFileContent.replaceAll("\\s+", ""))); pomFile.delete(); }
### Question: RxActivityResults { public <T> ObservableTransformer<T, ActivityResult> composer(final Intent intent) { return new ObservableTransformer<T, ActivityResult>() { @Override public ObservableSource<ActivityResult> apply(@NonNull Observable<T> upstream) { return request(upstream, intent); } }; } RxActivityResults(@NonNull Activity activity); ObservableTransformer<T, ActivityResult> composer(final Intent intent); ObservableTransformer<T, Boolean> ensureOkResult(final Intent intent); Observable<ActivityResult> start(Intent intent); void setLogging(boolean logging); }### Answer: @Test public void composer() throws Exception { Intent someIntent = new Intent(); ActivityResult testResult = new ActivityResult(Activity.RESULT_OK, Activity.RESULT_OK, someIntent); TestObserver<ActivityResult> composerTest = trigger().compose(rxActivityResults.composer(someIntent)).test(); rxActivityResults.onActivityResult(testResult.getResultCode(), someIntent); composerTest.assertNoErrors() .assertSubscribed() .assertComplete() .assertValueCount(1) .assertValue(testResult); } @Test(expected = IllegalArgumentException.class) public void requestNullIntent() throws Exception { TestObserver<ActivityResult> composerTest = trigger().compose(rxActivityResults.composer(null)).test(); composerTest.assertError(IllegalArgumentException.class) .assertSubscribed() .assertComplete() .assertValueCount(0); }
### Question: RxActivityResults { public <T> ObservableTransformer<T, Boolean> ensureOkResult(final Intent intent) { return new ObservableTransformer<T, Boolean>() { @Override public ObservableSource<Boolean> apply(@NonNull Observable<T> upstream) { return request(upstream, intent).map(new Function<ActivityResult, Boolean>() { @Override public Boolean apply(@NonNull ActivityResult activityResult) throws Exception { return activityResult.isOk(); } }); } }; } RxActivityResults(@NonNull Activity activity); ObservableTransformer<T, ActivityResult> composer(final Intent intent); ObservableTransformer<T, Boolean> ensureOkResult(final Intent intent); Observable<ActivityResult> start(Intent intent); void setLogging(boolean logging); }### Answer: @Test public void ensureOkResult() throws Exception { Intent someIntent = new Intent(); ActivityResult testResult = new ActivityResult(Activity.RESULT_OK, Activity.RESULT_OK, someIntent); TestObserver<Boolean> composerTest = trigger().compose(rxActivityResults.ensureOkResult(someIntent)).test(); rxActivityResults.onActivityResult(testResult.getResultCode(), someIntent); composerTest.assertNoErrors() .assertSubscribed() .assertComplete() .assertValueCount(1) .assertValue(testResult.isOk()); }
### Question: RxActivityResults { public Observable<ActivityResult> start(Intent intent) { return Observable.just(TRIGGER).compose(this.composer(intent)); } RxActivityResults(@NonNull Activity activity); ObservableTransformer<T, ActivityResult> composer(final Intent intent); ObservableTransformer<T, Boolean> ensureOkResult(final Intent intent); Observable<ActivityResult> start(Intent intent); void setLogging(boolean logging); }### Answer: @Test public void start() throws Exception { Intent someIntent = new Intent(); ActivityResult testResult = new ActivityResult(Activity.RESULT_OK, Activity.RESULT_OK, someIntent); TestObserver<ActivityResult> composerTest = rxActivityResults.start(someIntent).test(); rxActivityResults.onActivityResult(testResult.getResultCode(), someIntent); verify(rxActivityResults.mRxActivityResultsFragment) .onActivityResult(any(Integer.class), eq(testResult.getResultCode()), any(Intent.class)); composerTest.assertNoErrors() .assertSubscribed() .assertComplete() .assertValueCount(1) .assertValue(testResult); }
### Question: ActivityResult { @Override public boolean equals(Object obj) { if (obj instanceof ActivityResult) { if (this == obj) { return true; } ActivityResult activityResult = (ActivityResult) obj; return activityResult.data == data && activityResult.resultCode == resultCode; } else { return false; } } ActivityResult(int okResultCode, int resultCode, Intent data); Intent getData(); int getResultCode(); boolean isOk(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void equalsTrue() throws Exception { ActivityResult testResult = new ActivityResult(Activity.RESULT_OK, resultCode, intent); assertTrue(activityResult.equals(testResult)); assertTrue(activityResult.equals(activityResult)); } @Test public void equalsFalse() throws Exception { ActivityResult testResult = new ActivityResult(Activity.RESULT_OK, resultCode - 1, intent); assertFalse(activityResult.equals(testResult)); assertFalse(activityResult.equals(intent)); }
### Question: ActivityResult { public boolean isOk() { return resultCode == okResultCode; } ActivityResult(int okResultCode, int resultCode, Intent data); Intent getData(); int getResultCode(); boolean isOk(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void isOkTest() throws Exception { ActivityResult faultyResult = new ActivityResult(Activity.RESULT_OK, resultCode - 1, intent); assertFalse(faultyResult.isOk()); ActivityResult okResult = new ActivityResult(Activity.RESULT_OK, Activity.RESULT_OK, intent); assertTrue(okResult.isOk()); }
### Question: ActivityResult { @Override public String toString() { return "ActivityResult { ResultCode = " + resultCode + ", Data = " + data + " }"; } ActivityResult(int okResultCode, int resultCode, Intent data); Intent getData(); int getResultCode(); boolean isOk(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void toStringTest() throws Exception { String testResult = "ActivityResult { ResultCode" + " = " + resultCode + ", Data = " + intent + " }"; assertEquals(activityResult.toString(), testResult); }
### Question: ActivityResult { public Intent getData() { return data; } ActivityResult(int okResultCode, int resultCode, Intent data); Intent getData(); int getResultCode(); boolean isOk(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void getData() { assertEquals(activityResult.getData(), intent); }
### Question: ActivityResult { public int getResultCode() { return resultCode; } ActivityResult(int okResultCode, int resultCode, Intent data); Intent getData(); int getResultCode(); boolean isOk(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void getResultCode() { assertEquals(activityResult.getResultCode(), resultCode); }
### Question: DefaultAlertsPoliciesApi extends ApiBase implements AlertsPoliciesApi { @Override public Optional<AlertsPolicy> getByName(String alertsPolicyName) { Invocation.Builder builder = client .target(POLICIES_URL) .queryParam("filter[name]", alertsPolicyName) .request(APPLICATION_JSON_TYPE); return getPageable(builder, AlertsPolicyList.class) .filter(alertsPolicy -> alertsPolicy.getName().equals(alertsPolicyName)) .getSingle(); } DefaultAlertsPoliciesApi(NewRelicClient client); @Override Optional<AlertsPolicy> getByName(String alertsPolicyName); @Override AlertsPolicy create(AlertsPolicy policy); @Override AlertsPolicy delete(int policyId); @Override AlertsPolicyChannels updateChannels(AlertsPolicyChannels channels); }### Answer: @Test public void getByName_shouldReturnPolicy_whenClientReturnsNotUniqueResult() throws Exception { when(responseMock.readEntity(AlertsPolicyList.class)).thenReturn(new AlertsPolicyList(asList( AlertsPolicy.builder().name("policy").build(), AlertsPolicy.builder().name("policy1").build() ))); Optional<AlertsPolicy> policyOptional = testee.getByName("policy"); assertThat(policyOptional).isNotEmpty(); } @Test public void getByName_shouldNotReturnPolicy_whenClientReturnsNotMatchingResult() throws Exception { when(responseMock.readEntity(AlertsPolicyList.class)).thenReturn(new AlertsPolicyList(Collections.singletonList( AlertsPolicy.builder().name("policy1").build() ))); Optional<AlertsPolicy> policyOptional = testee.getByName("policy"); assertThat(policyOptional).isEmpty(); } @Test public void getByName_shouldNotReturnPolicy_whenClientReturnsEmptyList() throws Exception { when(responseMock.readEntity(AlertsPolicyList.class)).thenReturn(new AlertsPolicyList(Collections.emptyList())); Optional<AlertsPolicy> policyOptional = testee.getByName("policy"); assertThat(policyOptional).isEmpty(); }
### Question: DefaultApplicationsApi extends ApiBase implements ApplicationsApi { @Override public Optional<Application> getByName(String applicationName) { Invocation.Builder builder = client .target(APPLICATIONS_URL) .queryParam("filter[name]", applicationName) .request(APPLICATION_JSON_TYPE); return getPageable(builder, ApplicationList.class) .filter(application -> application.getName().equals(applicationName)) .getSingle(); } DefaultApplicationsApi(NewRelicClient client); @Override Optional<Application> getByName(String applicationName); @Override Application update(int applicationId, Application application); }### Answer: @Test public void getByName_shouldNotReturnApplication_whenClientReturnsNotMatchingResult() throws Exception { when(responseMock.readEntity(ApplicationList.class)).thenReturn(new ApplicationList(Collections.singletonList( Application.builder().name("app1").build() ))); Optional<Application> applicationOptional = testee.getByName("app"); assertThat(applicationOptional).isEmpty(); } @Test public void getByName_shouldNotReturnApplication_whenClientReturnsEmptyList() throws Exception { when(responseMock.readEntity(ApplicationList.class)).thenReturn(new ApplicationList(Collections.emptyList())); Optional<Application> applicationOptional = testee.getByName("app"); assertThat(applicationOptional).isEmpty(); } @Test public void getByName_shouldReturnApplication_whenClientReturnsNotUniqueResult() throws Exception { when(responseMock.readEntity(ApplicationList.class)).thenReturn(new ApplicationList(asList( Application.builder().name("app").build(), Application.builder().name("app1").build() ))); Optional<Application> applicationOptional = testee.getByName("app"); assertThat(applicationOptional).isNotEmpty(); }
### Question: Configurator { public void sync() { for (ApplicationConfiguration applicationConfiguration : applicationConfigurations) { applicationConfigurator.sync(applicationConfiguration); } for (PolicyConfiguration configuration : policyConfigurations) { policyConfigurator.sync(configuration); conditionConfigurator.sync(configuration); externalServiceConditionConfigurator.sync(configuration); nrqlConditionConfigurator.sync(configuration); syntheticsConditionConfigurator.sync(configuration); channelConfigurator.sync(configuration); } } Configurator(@NonNull String apiKey); Configurator(ApplicationConfigurator applicationConfigurator, PolicyConfigurator policyConfigurator, ConditionConfigurator conditionConfigurator, ExternalServiceConditionConfigurator externalServiceConditionConfigurator, NrqlConditionConfigurator nrqlConditionConfigurator, SyntheticsConditionConfigurator syntheticsConditionConfigurator, ChannelConfigurator channelConfigurator); void sync(); void setApplicationConfigurations(@NonNull Collection<ApplicationConfiguration> applicationConfigurations); void setPolicyConfigurations(@NonNull Collection<PolicyConfiguration> policyConfigurations); }### Answer: @Test public void shouldNotSynchronizeAnything_whenNoConfigurationsSet() { testee.sync(); InOrder order = inOrder(applicationConfiguratorMock, policyConfiguratorMock, conditionConfiguratorMock, externalServiceConditionConfiguratorMock, nrqlConditionConfiguratorMock, syntheticsConditionConfiguratorMock, channelConfiguratorMock); order.verifyNoMoreInteractions(); }
### Question: ApplicationConfigurator { void sync(@NonNull ApplicationConfiguration config) { LOG.info("Synchronizing application {}...", config.getApplicationName()); Application application = api.getApplicationsApi().getByName(config.getApplicationName()).orElseThrow( () -> new NewRelicSyncException(format("Application %s does not exist", config.getApplicationName()))); ApplicationSettings settings = ApplicationSettings.builder() .appApdexThreshold(config.getAppApdexThreshold()) .endUserApdexThreshold(config.getEndUserApdexThreshold()) .enableRealUserMonitoring(config.isEnableRealUserMonitoring()) .build(); Application applicationUpdate = Application.builder() .name(config.getApplicationName()) .settings(settings) .build(); api.getApplicationsApi().update(application.getId(), applicationUpdate); LOG.info("Application {} synchronized", config.getApplicationName()); } ApplicationConfigurator(@NonNull NewRelicApi api); }### Answer: @Test public void shouldThrowException_whenApplicationDoesNotExist() { when(applicationsApiMock.getByName(APPLICATION_NAME)).thenReturn(Optional.empty()); expectedException.expect(NewRelicSyncException.class); expectedException.expectMessage(format("Application %s does not exist", APPLICATION_NAME)); testee.sync(CONFIGURATION); } @Test public void shouldUpdateApplication() { when(applicationsApiMock.getByName(APPLICATION_NAME)).thenReturn(Optional.of(APPLICATION)); ApplicationSettings expectedSettings = ApplicationSettings.builder() .appApdexThreshold(APP_APDEX_THRESHOLD) .endUserApdexThreshold(USER_APDEX_THRESHOLD) .enableRealUserMonitoring(ENABLE_REAL_USER_MONITORING) .build(); Application expectedApplicationUpdate = Application.builder() .name(APPLICATION_NAME) .settings(expectedSettings) .build(); testee.sync(CONFIGURATION); verify(applicationsApiMock).update(APPLICATION.getId(), expectedApplicationUpdate); }
### Question: PolicyConfigurator { void sync(@NonNull PolicyConfiguration config) { LOG.info("Synchronizing policy {}...", config.getPolicyName()); AlertsPolicy alertsPolicyFromConfig = AlertsPolicy.builder() .name(config.getPolicyName()) .incidentPreference(config.getIncidentPreference().name()) .build(); Optional<AlertsPolicy> policy = api.getAlertsPoliciesApi().getByName(config.getPolicyName()); if (policy.isPresent()) { AlertsPolicy oldPolicy = policy.get(); if (!StringUtils.equals(alertsPolicyFromConfig.getIncidentPreference(), oldPolicy.getIncidentPreference())) { api.getAlertsPoliciesApi().delete(oldPolicy.getId()); api.getAlertsPoliciesApi().create(alertsPolicyFromConfig); LOG.info(format("Policy %s updated", config.getPolicyName())); } } else { api.getAlertsPoliciesApi().create(alertsPolicyFromConfig); LOG.info("Policy {} created", config.getPolicyName()); } LOG.info("Policy {} synchronized", config.getPolicyName()); } PolicyConfigurator(@NonNull NewRelicApi api); }### Answer: @Test public void shouldCreateNewPolicy_whenPolicyDoesNotExist() { when(alertsPoliciesApiMock.getByName(POLICY_NAME)).thenReturn(Optional.empty()); AlertsPolicy expectedPolicy = AlertsPolicy.builder().name(POLICY_NAME).incidentPreference(INCIDENT_PREFERENCE.name()).build(); testee.sync(CONFIGURATION); InOrder order = inOrder(alertsPoliciesApiMock); order.verify(alertsPoliciesApiMock).getByName(POLICY_NAME); order.verify(alertsPoliciesApiMock).create(expectedPolicy); order.verifyNoMoreInteractions(); } @Test public void shouldDeleteAndCreateNewPolicy_whenPolicyUpdated() { when(alertsPoliciesApiMock.getByName(POLICY_NAME)).thenReturn(Optional.of(ALERT_POLICY_DIFFERENT)); AlertsPolicy expectedPolicy = AlertsPolicy.builder().name(POLICY_NAME).incidentPreference(INCIDENT_PREFERENCE.name()).build(); testee.sync(CONFIGURATION); InOrder order = inOrder(alertsPoliciesApiMock); order.verify(alertsPoliciesApiMock).getByName(POLICY_NAME); order.verify(alertsPoliciesApiMock).delete(ALERT_POLICY_DIFFERENT.getId()); order.verify(alertsPoliciesApiMock).create(expectedPolicy); order.verifyNoMoreInteractions(); } @Test public void shouldDoNothing_whenPolicyNotUpdated() { when(alertsPoliciesApiMock.getByName(POLICY_NAME)).thenReturn(Optional.of(ALERT_POLICY_SAME)); testee.sync(CONFIGURATION); InOrder order = inOrder(alertsPoliciesApiMock); order.verify(alertsPoliciesApiMock).getByName(POLICY_NAME); order.verifyNoMoreInteractions(); }
### Question: DefaultDashboardsApi extends ApiBase implements DashboardsApi { @Override public List<Dashboard> getByTitle(String dashboardTitle) { String dashboardTitleEncoded = UriComponent.encode(dashboardTitle, QUERY_PARAM_SPACE_ENCODED); Invocation.Builder builder = client .target(DASHBOARDS_URL) .queryParam("filter[title]", dashboardTitleEncoded) .request(APPLICATION_JSON_TYPE); return getPageable(builder, DashboardList.class) .getList(); } DefaultDashboardsApi(NewRelicClient client); @Override Dashboard getById(int dashboardId); @Override List<Dashboard> getByTitle(String dashboardTitle); @Override Dashboard create(Dashboard dashboard); @Override Dashboard update(Dashboard dashboard); @Override Dashboard delete(int dashboardId); }### Answer: @Test public void getByTitle_shouldReturnDashboards_whenClientReturnsNotUniqueResult() { when(responseMock.readEntity(DashboardList.class)).thenReturn(new DashboardList(asList( Dashboard.builder().title(DASHBOARD_FILTER_VALUE).build(), Dashboard.builder().title("dashboard1").build() ))); List<Dashboard> dashboard = testee.getByTitle(DASHBOARD_FILTER_VALUE); assertThat(dashboard).isNotEmpty(); assertThat(dashboard).hasSize(2); } @Test public void getByTitle_shouldReturnDashboard_whenClientReturnsResultContainingQueriedTitle() { when(responseMock.readEntity(DashboardList.class)).thenReturn(new DashboardList(Collections.singletonList( Dashboard.builder().title("dashboard1").build() ))); List<Dashboard> dashboard = testee.getByTitle(DASHBOARD_FILTER_VALUE); assertThat(dashboard).isNotEmpty(); } @Test public void getByTitle_shouldNotReturnDashboard_whenClientReturnsEmptyList() { when(responseMock.readEntity(DashboardList.class)).thenReturn(new DashboardList(Collections.emptyList())); List<Dashboard> dashboard = testee.getByTitle(DASHBOARD_FILTER_VALUE); assertThat(dashboard).isEmpty(); }
### Question: DefaultServersApi extends ApiBase implements ServersApi { @Override public Optional<Server> getByName(String serverName) { String serverNameEncoded = UriComponent.encode(serverName, QUERY_PARAM_SPACE_ENCODED); Invocation.Builder builder = client .target(SERVERS_URL) .queryParam("filter[name]", serverNameEncoded) .request(APPLICATION_JSON_TYPE); return getPageable(builder, ServerList.class) .filter(application -> application.getName().equals(serverName)) .getSingle(); } DefaultServersApi(NewRelicClient client); @Override Optional<Server> getByName(String serverName); @Override Server getById(int serverId); }### Answer: @Test public void getByName_shouldReturnServer_whenClientReturnsNotUniqueResult() throws Exception { when(responseMock.readEntity(ServerList.class)).thenReturn(new ServerList(asList( Server.builder().name("server").build(), Server.builder().name("server1").build() ))); Optional<Server> serverOptional = testee.getByName("server"); assertThat(serverOptional).isNotEmpty(); } @Test public void getByName_shouldNotReturnServer_whenClientReturnsNotMatchingResult() throws Exception { when(responseMock.readEntity(ServerList.class)).thenReturn(new ServerList(Collections.singletonList( Server.builder().name("server1").build() ))); Optional<Server> serverOptional = testee.getByName("server"); assertThat(serverOptional).isEmpty(); } @Test public void getByName_shouldNotReturnServer_whenClientReturnsEmptyList() throws Exception { when(responseMock.readEntity(ServerList.class)).thenReturn(new ServerList(Collections.emptyList())); Optional<Server> serverOptional = testee.getByName("server"); assertThat(serverOptional).isEmpty(); }
### Question: EmbeddedJMSBrokerHolder implements AutoCloseable, ConnectionFactoryAccessor, ActiveMQConnectionFactoryAccessor, BrokerURIAccessor { public static EmbeddedJMSBrokerHolder create(final String name, boolean marshal, boolean persistent) { final File tempDir = Files.createTempDir(); LOGGER.debug("Created temporary directory: \"{}\"", tempDir.getAbsolutePath()); return new EmbeddedJMSBrokerHolder(createAndConfigureBrokerService(new BrokerSettings(name, marshal, persistent, tempDir)), tempDir); } EmbeddedJMSBrokerHolder(final BrokerService brokerService, final File tempDir); BrokerService getBrokerService(); @Override ConnectionFactory getConnectionFactory(); @Override ActiveMQConnectionFactory getActiveMQConnectionFactory(); @Override URI getBrokerUri(); static EmbeddedJMSBrokerHolder create(final String name, boolean marshal, boolean persistent); void start(); @Override void close(); }### Answer: @DisplayName("Create EmbeddedJMSBrokerHolder instance") @Test void create() throws Exception { try (final EmbeddedJMSBrokerHolder embeddedJmsBrokerHolder = EmbeddedJMSBrokerHolder .create("name", false, false)) { assertNotNull(embeddedJmsBrokerHolder.getBrokerService()); assertFalse(embeddedJmsBrokerHolder.getBrokerService().isStarted()); } } @DisplayName("Creating a broker using an illegal URI as name should fail") @Test void createFails() { assertThrows(IllegalStateException.class, () -> EmbeddedJMSBrokerHolder .create("\\\\\\", false, false)); }
### Question: EmbeddedJmsRuleImpl implements EmbeddedJmsRule { @Override public ConnectionFactory connectionFactory() { return activeMqConnectionFactory(); } EmbeddedJmsRuleImpl(final String predefinedName, final boolean marshal, final boolean persistent); @Override ConnectionFactory connectionFactory(); @Override ActiveMQConnectionFactory activeMqConnectionFactory(); @Override URI brokerUri(); @Override Statement apply(final Statement base, final Description description); }### Answer: @Test(expected = IllegalStateException.class) public void connectionFactory() throws Exception { final EmbeddedJmsRuleImpl rule = new EmbeddedJmsRuleImpl("predefined", true, false); rule.connectionFactory(); }
### Question: EmbeddedJmsRuleImpl implements EmbeddedJmsRule { @Override public ActiveMQConnectionFactory activeMqConnectionFactory() { if (jmsBrokerHolder == null) { throw new IllegalStateException("Can not create ConnectionFactory before the broker has started"); } else { return jmsBrokerHolder.getActiveMQConnectionFactory(); } } EmbeddedJmsRuleImpl(final String predefinedName, final boolean marshal, final boolean persistent); @Override ConnectionFactory connectionFactory(); @Override ActiveMQConnectionFactory activeMqConnectionFactory(); @Override URI brokerUri(); @Override Statement apply(final Statement base, final Description description); }### Answer: @Test(expected = IllegalStateException.class) public void activeMqConnectionFactory() throws Exception { final EmbeddedJmsRuleImpl rule = new EmbeddedJmsRuleImpl("predefined", true, false); rule.activeMqConnectionFactory(); }
### Question: EmbeddedJmsRuleImpl implements EmbeddedJmsRule { @Override public URI brokerUri() { if (jmsBrokerHolder == null) { throw new IllegalStateException("Can not create broker URI before the broker has started"); } else { return jmsBrokerHolder.getBrokerUri(); } } EmbeddedJmsRuleImpl(final String predefinedName, final boolean marshal, final boolean persistent); @Override ConnectionFactory connectionFactory(); @Override ActiveMQConnectionFactory activeMqConnectionFactory(); @Override URI brokerUri(); @Override Statement apply(final Statement base, final Description description); }### Answer: @Test(expected = IllegalStateException.class) public void brokerUri() throws Exception { final EmbeddedJmsRuleImpl rule = new EmbeddedJmsRuleImpl("predefined", true, false); rule.brokerUri(); }
### Question: BrokerConfiguration { @Override public int hashCode() { return Objects.hash(name, marshal, persistenceEnabled); } BrokerConfiguration(final String name, final Boolean marshal, final Boolean persistenceEnabled); String getName(); Boolean getMarshal(); Boolean getPersistenceEnabled(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); static final BrokerConfiguration DEFAULT; }### Answer: @Test void testHashCode() { assertEquals(BrokerConfigurationBuilder.instance().build().hashCode(), BrokerConfigurationBuilder.instance().build().hashCode()); }
### Question: BrokerConfiguration { @Override public String toString() { final StringBuilder sb = new StringBuilder("BrokerConfiguration{"); sb.append("name='").append(name).append('\''); sb.append(", marshal=").append(marshal); sb.append(", persistenceEnabled=").append(persistenceEnabled); sb.append('}'); return sb.toString(); } BrokerConfiguration(final String name, final Boolean marshal, final Boolean persistenceEnabled); String getName(); Boolean getMarshal(); Boolean getPersistenceEnabled(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); static final BrokerConfiguration DEFAULT; }### Answer: @Test void testToString() { assertEquals(BrokerConfigurationBuilder.instance().build().toString(), BrokerConfigurationBuilder.instance().build().toString()); }
### Question: ZeebeExpressionResolver implements BeanFactoryAware { @SuppressWarnings("unchecked") public <T> T resolve(final String value) { final String resolvedValue = resolve.apply(value); if (!(resolvedValue.startsWith("#{") && value.endsWith("}"))) { return (T) resolvedValue; } return (T) this.resolver.evaluate(resolvedValue, this.expressionContext); } @Override void setBeanFactory(final BeanFactory beanFactory); @SuppressWarnings("unchecked") T resolve(final String value); }### Answer: @Test public void resolveNetworkClientPort() throws Exception { final String port = resolver.resolve("${zeebe.network.client.port}"); assertThat(port).isEqualTo("123"); } @Test public void useValueIfNoExpression() throws Exception { final String normalString = resolver.resolve("normalString"); assertThat(normalString).isEqualTo("normalString"); }
### Question: DeploymentPostProcessor extends BeanInfoPostProcessor { @Override public Consumer<ZeebeClient> apply(final ClassInfo beanInfo) { final ZeebeDeploymentValue value = reader.applyOrThrow(beanInfo); log.info("deployment: {}", value); return client -> { DeployWorkflowCommandStep1 deployWorkflowCommand = client .newDeployCommand(); DeploymentEvent deploymentResult = value.getClassPathResources() .stream() .map(deployWorkflowCommand::addResourceFromClasspath) .reduce((first, second) -> second) .orElseThrow(() -> new IllegalArgumentException("Requires at least one resource to deploy")) .send() .join(); log.info( "Deployed: {}", deploymentResult .getWorkflows() .stream() .map(wf -> String.format("<%s:%d>", wf.getBpmnProcessId(), wf.getVersion())) .collect(Collectors.joining(","))); }; } @Override boolean test(final ClassInfo beanInfo); @Override Consumer<ZeebeClient> apply(final ClassInfo beanInfo); }### Answer: @Test public void shouldDeploySingleResourceTest() { ClassInfo classInfo = ClassInfo.builder() .build(); ZeebeDeploymentValue zeebeDeploymentValue = ZeebeDeploymentValue.builder() .classPathResources(Collections.singletonList("/1.bpmn")) .build(); when(reader.applyOrThrow(classInfo)).thenReturn(zeebeDeploymentValue); when(client.newDeployCommand()).thenReturn(deployStep1); when(deployStep1.addResourceFromClasspath(anyString())).thenReturn(deployStep2); when(deployStep2.send()).thenReturn(zeebeFuture); when(zeebeFuture.join()).thenReturn(deploymentEvent); when(deploymentEvent.getWorkflows()).thenReturn(Collections.singletonList(getWorkFlow())); deploymentPostProcessor.apply(classInfo).accept(client); verify(deployStep1).addResourceFromClasspath(eq("/1.bpmn")); verify(deployStep2).send(); verify(zeebeFuture).join(); } @Test public void shouldDeployMultipleResourcesTest() { ClassInfo classInfo = ClassInfo.builder() .build(); ZeebeDeploymentValue zeebeDeploymentValue = ZeebeDeploymentValue.builder() .classPathResources(Arrays.asList("/1.bpmn", "/2.bpmn")) .build(); when(reader.applyOrThrow(classInfo)).thenReturn(zeebeDeploymentValue); when(client.newDeployCommand()).thenReturn(deployStep1); when(deployStep1.addResourceFromClasspath(anyString())).thenReturn(deployStep2); when(deployStep2.send()).thenReturn(zeebeFuture); when(zeebeFuture.join()).thenReturn(deploymentEvent); when(deploymentEvent.getWorkflows()).thenReturn(Collections.singletonList(getWorkFlow())); deploymentPostProcessor.apply(classInfo).accept(client); verify(deployStep1).addResourceFromClasspath(eq("/1.bpmn")); verify(deployStep1).addResourceFromClasspath(eq("/2.bpmn")); verify(deployStep2).send(); verify(zeebeFuture).join(); } @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionOnNoResourcesToDeploy() { ClassInfo classInfo = ClassInfo.builder() .build(); ZeebeDeploymentValue zeebeDeploymentValue = ZeebeDeploymentValue.builder() .classPathResources(Collections.emptyList()) .build(); when(reader.applyOrThrow(classInfo)).thenReturn(zeebeDeploymentValue); when(client.newDeployCommand()).thenReturn(deployStep1); when(deployStep1.addResourceFromClasspath(anyString())).thenReturn(deployStep2); deploymentPostProcessor.apply(classInfo).accept(client); }
### Question: ReadZeebeDeploymentValue extends ReadAnnotationValue<ClassInfo, ZeebeDeployment, ZeebeDeploymentValue> { @Override public Optional<ZeebeDeploymentValue> apply(final ClassInfo classInfo) { return classInfo .getAnnotation(annotationType) .map( annotation -> ZeebeDeploymentValue.builder() .beanInfo(classInfo) .classPathResources( resolveResources(annotation.classPathResources()) ) .build()); } ReadZeebeDeploymentValue(final ZeebeExpressionResolver resolver); @Override Optional<ZeebeDeploymentValue> apply(final ClassInfo classInfo); }### Answer: @Test public void shouldReadSingleClassPathResourceTest() { ClassInfo classInfo = ClassInfo.builder() .bean(new WithSingleClassPathResource()) .build(); when(expressionResolver.resolve(anyString())).thenAnswer(inv -> inv.getArgument(0)); ZeebeDeploymentValue expectedDeploymentValue = ZeebeDeploymentValue.builder() .beanInfo(classInfo) .classPathResources(Collections.singletonList("/1.bpmn")) .build(); Optional<ZeebeDeploymentValue> valueForClass = readZeebeDeploymentValue.apply(classInfo); assertTrue(valueForClass.isPresent()); assertEquals(expectedDeploymentValue, valueForClass.get()); } @Test public void shouldReadMultipleClassPathResourcesTest() { ClassInfo classInfo = ClassInfo.builder() .bean(new WithMultipleClassPathResource()) .build(); when(expressionResolver.resolve(anyString())).thenAnswer(inv -> inv.getArgument(0)); ZeebeDeploymentValue expectedDeploymentValue = ZeebeDeploymentValue.builder() .beanInfo(classInfo) .classPathResources(Arrays.asList("/1.bpmn", "/2.bpmn")) .build(); Optional<ZeebeDeploymentValue> valueForClass = readZeebeDeploymentValue.apply(classInfo); assertTrue(valueForClass.isPresent()); assertEquals(expectedDeploymentValue, valueForClass.get()); } @Test public void shouldReadNoClassPathResourcesTest() { ClassInfo classInfo = ClassInfo.builder() .bean(new WithoutAnnotation()) .build(); when(expressionResolver.resolve(anyString())).thenAnswer(inv -> inv.getArgument(0)); Optional<ZeebeDeploymentValue> valueForClass = readZeebeDeploymentValue.apply(classInfo); assertFalse(valueForClass.isPresent()); }
### Question: Experiment { public <I, D> Experiment(LearningAlgorithm<? extends A, I, D> learningAlgorithm, EquivalenceOracle<? super A, I, D> equivalenceAlgorithm, Alphabet<I> inputs) { this.impl = new ExperimentImpl<>(learningAlgorithm, equivalenceAlgorithm, inputs); } <I, D> Experiment(LearningAlgorithm<? extends A, I, D> learningAlgorithm, EquivalenceOracle<? super A, I, D> equivalenceAlgorithm, Alphabet<I> inputs); A run(); A getFinalHypothesis(); void setLogModels(boolean logModels); void setProfile(boolean profile); Counter getRounds(); static final String LEARNING_PROFILE_KEY; static final String COUNTEREXAMPLE_PROFILE_KEY; }### Answer: @Test public void testExperiment() { final Alphabet<Character> alphabet = Alphabets.characters('a', 'c'); final CompactDFA<Character> target = RandomAutomata.randomDFA(RANDOM, 5, alphabet); final CompactDFA<Character> intermediateTarget = RandomAutomata.randomDFA(RANDOM, target.size() - 1, alphabet); final MockUpLearner<Character> learner = new MockUpLearner<>(target, intermediateTarget); final DFAEquivalenceOracle<Character> eq = new MockUpOracle<>(intermediateTarget); DFAExperiment<Character> experiment = new DFAExperiment<>(learner, eq, alphabet); experiment.setProfile(true); Assert.assertThrows(experiment::getFinalHypothesis); experiment.run(); Assert.assertThrows(experiment::run); DFA<?, Character> finalModel = experiment.getFinalHypothesis(); Assert.assertNotNull(experiment.getFinalHypothesis()); Assert.assertSame(finalModel, target); Assert.assertTrue(learner.startLearningCalled); Assert.assertEquals(learner.refinementSteps, REFINEMENT_STEPS); Assert.assertNotNull(SimpleProfiler.cumulated(Experiment.LEARNING_PROFILE_KEY)); Assert.assertNotNull(SimpleProfiler.cumulated(Experiment.COUNTEREXAMPLE_PROFILE_KEY)); }
### Question: AbstractBFInclusionOracle extends AbstractBFOracle<A, I, D> implements InclusionOracle<A, I, D> { @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { return super.findCounterExample(hypothesis, inputs); } AbstractBFInclusionOracle(MembershipOracle<I, D> membershipOracle, double multiplier); @Override boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, D output); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }### Answer: @Test public void testFindCounterExample() { final DefaultQuery<Character, D> cex = bfio.findCounterExample(automaton, ALPHABET); Assert.assertEquals(cex, query); }
### Question: CExFirstOracle implements BlackBoxOracle<A, I, D> { @Override public List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles() { return propertyOracles; } CExFirstOracle(); CExFirstOracle(PropertyOracle<I, A, ?, D> propertyOracle); CExFirstOracle(Collection<? extends PropertyOracle<I, ? super A, ?, D>> propertyOracles); @Override List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles(); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }### Answer: @Test public void testGetPropertyOracles() { Assert.assertEquals(oracle.getPropertyOracles().size(), 2); }
### Question: CExFirstOracle implements BlackBoxOracle<A, I, D> { @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { for (PropertyOracle<I, ? super A, ?, D> propertyOracle : propertyOracles) { final DefaultQuery<I, D> result = propertyOracle.findCounterExample(hypothesis, inputs); if (result != null) { assert isCounterExample(hypothesis, result.getInput(), result.getOutput()); return result; } } return null; } CExFirstOracle(); CExFirstOracle(PropertyOracle<I, A, ?, D> propertyOracle); CExFirstOracle(Collection<? extends PropertyOracle<I, ? super A, ?, D>> propertyOracles); @Override List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles(); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }### Answer: @Test public void testFindCounterExample() { final DefaultQuery<Boolean, Boolean> ce = oracle.findCounterExample(automaton, inputs); Assert.assertEquals(ce, query); Mockito.verify(po1).disprove(automaton, inputs); Mockito.verify(po2, Mockito.never()).disprove(automaton, inputs); Mockito.verify(po2, Mockito.never()).findCounterExample(automaton, inputs); }
### Question: RandomWalkEQOracle implements MealyEquivalenceOracle<I, O> { @Override public @Nullable DefaultQuery<I, Word<O>> findCounterExample(MealyMachine<?, I, ?, O> hypothesis, Collection<? extends I> inputs) { return doFindCounterExample(hypothesis, inputs); } RandomWalkEQOracle(SUL<I, O> sul, double restartProbability, long maxSteps, boolean resetStepCount, Random random); RandomWalkEQOracle(SUL<I, O> sul, double restartProbability, long maxSteps, Random random); @Override @Nullable DefaultQuery<I, Word<O>> findCounterExample(MealyMachine<?, I, ?, O> hypothesis, Collection<? extends I> inputs); }### Answer: @Test public void testOracle() { final DummySUL dummySUL = new DummySUL(); final MealyEquivalenceOracle<Character, Character> mOracle = new RandomWalkEQOracle<>(dummySUL, 0.01, MAX_LENGTH, new Random(42)); final DefaultQuery<Character, Word<Character>> ce = mOracle.findCounterExample(new DummyMealy(ALPHABET), ALPHABET); Assert.assertNull(ce); Assert.assertTrue(dummySUL.isCalledPost()); }
### Question: SULSymbolQueryOracle implements SymbolQueryOracle<I, O> { @Override public void reset() { if (postRequired) { this.sul.post(); this.postRequired = false; } this.preRequired = true; } SULSymbolQueryOracle(final SUL<I, O> sul); @Override O query(I i); @Override void reset(); }### Answer: @Test public void testResetIdempotency() { final SUL<Character, Integer> mock = Mockito.spy(sul); final SULSymbolQueryOracle<Character, Integer> oracle = new SULSymbolQueryOracle<>(mock); Mockito.verify(mock, Mockito.times(0)).pre(); Mockito.verify(mock, Mockito.times(0)).post(); oracle.reset(); oracle.reset(); oracle.reset(); Mockito.verify(mock, Mockito.times(0)).pre(); Mockito.verify(mock, Mockito.times(0)).post(); } @Test public void testQueriesAndCleanUp() { final SUL<Character, Integer> mock = Mockito.spy(sul); final SULSymbolQueryOracle<Character, Integer> oracle = new SULSymbolQueryOracle<>(mock); Mockito.verify(mock, Mockito.times(0)).pre(); Mockito.verify(mock, Mockito.times(0)).post(); final Word<Character> i1 = Word.fromCharSequence("abcabcabc"); final Word<Integer> o1 = oracle.answerQuery(i1); oracle.reset(); Assert.assertEquals(o1, example.getReferenceAutomaton().computeOutput(i1)); Mockito.verify(mock, Mockito.times(1)).pre(); Mockito.verify(mock, Mockito.times(1)).post(); Mockito.verify(mock, Mockito.times(i1.size())).step(Mockito.anyChar()); final Word<Character> i2 = Word.fromCharSequence("cba"); final Word<Integer> o2 = oracle.answerQuery(i2); oracle.reset(); oracle.reset(); Assert.assertEquals(o2, example.getReferenceAutomaton().computeOutput(i2)); Mockito.verify(mock, Mockito.times(2)).pre(); Mockito.verify(mock, Mockito.times(2)).post(); Mockito.verify(mock, Mockito.times(i1.size() + i2.size())).step(Mockito.anyChar()); }
### Question: SimulatorOmegaOracle implements SingleQueryOmegaOracle<S, I, D> { @Override public void processQueries(Collection<? extends OmegaQuery<I, D>> queries) { MQUtil.answerOmegaQueries(this, queries); } <A extends SuffixOutput<I, D> & SimpleDTS<S, I>> SimulatorOmegaOracle(A automaton, SimulatorOracle<I, D> simulatorOracle); @Override MembershipOracle<I, D> getMembershipOracle(); @Override boolean isSameState(Word<I> input1, S s1, Word<I> input2, S s2); @Override void processQueries(Collection<? extends OmegaQuery<I, D>> queries); @Override Pair<D, Integer> answerQuery(Word<I> prefix, Word<I> loop, int repeat); }### Answer: @Test public void testDFASimulatorOmegaOracle() { DFA<Integer, Symbol> dfa = ExamplePaulAndMary.constructMachine(); DFASimulatorOmegaOracle<Integer, Symbol> oracle = new DFASimulatorOmegaOracle<>(dfa); List<OmegaQuery<Symbol, Boolean>> queries = new ArrayList<>(); OmegaQuery<Symbol, Boolean> q1 = new OmegaQuery<>(Word.epsilon(), Word.fromSymbols(ExamplePaulAndMary.IN_PAUL, ExamplePaulAndMary.IN_LOVES, ExamplePaulAndMary.IN_MARY), 1); OmegaQuery<Symbol, Boolean> q2 = new OmegaQuery<>(Word.fromSymbols(ExamplePaulAndMary.IN_MARY), Word.fromSymbols(ExamplePaulAndMary.IN_MARY, ExamplePaulAndMary.IN_LOVES, ExamplePaulAndMary.IN_PAUL), 1); queries.add(q1); queries.add(q2); Assert.assertEquals(queries.get(0).getLoop().size(), 3); Assert.assertEquals(queries.get(1).getLoop().size(), 3); oracle.processQueries(queries); Assert.assertFalse(queries.get(0).isUltimatelyPeriodic()); Assert.assertTrue(queries.get(1).isUltimatelyPeriodic()); Assert.assertEquals(queries.get(1).getOutput(), Boolean.FALSE); }
### Question: SimulatorOracle implements SingleQueryOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { MQUtil.answerQueries(this, queries); } SimulatorOracle(SuffixOutput<I, D> automaton); @Override D answerQuery(Word<I> prefix, Word<I> suffix); @Override void processQueries(Collection<? extends Query<I, D>> queries); }### Answer: @Test public void testDFASimulatorOracle() { DFA<?, Symbol> dfa = ExamplePaulAndMary.constructMachine(); SimulatorOracle<Symbol, Boolean> oracle = new SimulatorOracle<>(dfa); List<DefaultQuery<Symbol, Boolean>> queries = new ArrayList<>(); DefaultQuery<Symbol, Boolean> q1 = new DefaultQuery<>(Word.fromSymbols(ExamplePaulAndMary.IN_PAUL, ExamplePaulAndMary.IN_LOVES, ExamplePaulAndMary.IN_MARY)); DefaultQuery<Symbol, Boolean> q2 = new DefaultQuery<>(Word.fromSymbols(ExamplePaulAndMary.IN_MARY, ExamplePaulAndMary.IN_LOVES, ExamplePaulAndMary.IN_PAUL)); queries.add(q1); queries.add(q2); Assert.assertEquals(queries.get(0).getInput().size(), 3); Assert.assertEquals(queries.get(1).getInput().size(), 3); oracle.processQueries(queries); Assert.assertEquals(queries.get(0).getOutput(), Boolean.TRUE); Assert.assertEquals(queries.get(1).getOutput(), Boolean.FALSE); }
### Question: StateLocalInputSULSymbolQueryOracle extends SULSymbolQueryOracle<I, O> implements SymbolQueryOracle<I, O> { @Override public void reset() { super.reset(); this.fetchRequired = true; } StateLocalInputSULSymbolQueryOracle(StateLocalInputSUL<I, O> sul, O undefinedOutput); @Override void reset(); }### Answer: @Test public void testResetIdempotency() { final StateLocalInputSUL<Character, Integer> mock = Mockito.spy(sul); Mockito.doAnswer(invocation -> Collections.singleton('a')).when(mock).currentlyEnabledInputs(); final SULSymbolQueryOracle<Character, Integer> oracle = new StateLocalInputSULSymbolQueryOracle<>(mock, example.getUndefinedOutput()); Mockito.verify(mock, Mockito.times(0)).pre(); Mockito.verify(mock, Mockito.times(0)).post(); Mockito.verify(mock, Mockito.times(0)).currentlyEnabledInputs(); oracle.reset(); oracle.reset(); oracle.reset(); Mockito.verify(mock, Mockito.times(0)).pre(); Mockito.verify(mock, Mockito.times(0)).post(); Mockito.verify(mock, Mockito.times(0)).currentlyEnabledInputs(); } @Test public void testQueriesAndCleanUp() { final StateLocalInputSUL<Character, Integer> mock = Mockito.spy(sul); Mockito.doAnswer(invocation -> Collections.singleton('a')).when(mock).currentlyEnabledInputs(); final SULSymbolQueryOracle<Character, Integer> oracle = new StateLocalInputSULSymbolQueryOracle<>(mock, example.getUndefinedOutput()); Mockito.verify(mock, Mockito.times(0)).pre(); Mockito.verify(mock, Mockito.times(0)).post(); final Word<Character> i1 = Word.fromCharSequence("abcabcabc"); final Word<Integer> o1 = oracle.answerQuery(i1); oracle.reset(); Assert.assertEquals(o1.firstSymbol(), example.getReferenceAutomaton().computeOutput(i1).firstSymbol()); Assert.assertEquals(o1.subWord(1), Word.fromList(Collections.nCopies(i1.size() - 1, example.getUndefinedOutput()))); Mockito.verify(mock, Mockito.times(1)).pre(); Mockito.verify(mock, Mockito.times(1)).post(); Mockito.verify(mock, Mockito.times(2)).currentlyEnabledInputs(); Mockito.verify(mock, Mockito.times(1)).step(Mockito.anyChar()); final Word<Character> i2 = Word.fromCharSequence("aaaaa"); final Word<Integer> o2 = oracle.answerQuery(i2); oracle.reset(); oracle.reset(); Assert.assertEquals(o2, example.getReferenceAutomaton().computeOutput(i2)); Mockito.verify(mock, Mockito.times(2)).pre(); Mockito.verify(mock, Mockito.times(2)).post(); Mockito.verify(mock, Mockito.times(2 + i2.size())).currentlyEnabledInputs(); Mockito.verify(mock, Mockito.times(1 + i2.size())).step(Mockito.anyChar()); }
### Question: SULMapperComposition extends MapperComposition<AI, AO, ACI, CAO, CI, CO, SULMapper<? super AI, ? extends AO, ACI, CAO>, SULMapper<? super ACI, ? extends CAO, ? extends CI, ? super CO>> implements SULMapper<AI, AO, CI, CO> { @Override public boolean canFork() { return mapper1.canFork() && mapper2.canFork(); } SULMapperComposition(SULMapper<? super AI, ? extends AO, ACI, CAO> outerMapper, SULMapper<? super ACI, ? extends CAO, ? extends CI, ? super CO> innerMapper); @SuppressWarnings("PMD.AvoidCatchingGenericException") // we want to allow mapping generic RuntimeExceptions @Override MappedException<? extends AO> mapWrappedException(SULException exception); @SuppressWarnings("PMD.AvoidCatchingGenericException") // we want to allow mapping generic RuntimeExceptions @Override MappedException<? extends AO> mapUnwrappedException(RuntimeException exception); @Override boolean canFork(); @Override SULMapper<AI, AO, CI, CO> fork(); }### Answer: @Test public void testComposition() { mappedSUL.pre(); Character result = mappedSUL.step('A'); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), 'A'); result = mappedSUL.step(INNER_EXCEPTION_TRIGGER_CHAR); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), INNER_EXCEPTION_TRIGGER_CHAR); result = mappedSUL.step('C'); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), INNER_EXCEPTION_TRIGGER_CHAR); result = mappedSUL.step(null); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), INNER_EXCEPTION_TRIGGER_CHAR); mappedSUL.post(); mappedSUL.pre(); result = mappedSUL.step('A'); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), 'A'); result = mappedSUL.step(OUTER_EXCEPTION_TRIGGER_CHAR); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), OUTER_EXCEPTION_RESULT); result = mappedSUL.step('C'); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), 'C'); result = mappedSUL.step(NESTED_EXCEPTION_TRIGGER_CHAR); Assert.assertNotNull(result); Assert.assertEquals(result.charValue(), NESTED_EXCEPTION_TRIGGER_CHAR); Assert.assertThrows(NullPointerException.class, () -> mappedSUL.step(null)); mappedSUL.post(); mappedSUL.pre(); mappedSUL.pre(); Assert.assertEquals(4, this.innerUnwrappedMapper.getPreCounter()); Assert.assertEquals(4, this.outerWrappedMapper.getPreCounter()); Assert.assertEquals(2, this.innerUnwrappedMapper.getPostCounter()); Assert.assertEquals(2, this.outerWrappedMapper.getPostCounter()); Assert.assertFalse(mappedSUL.canFork()); Assert.assertThrows(mappedSUL::fork); }
### Question: StaticParallelOmegaOracle extends AbstractStaticBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); } StaticParallelOmegaOracle(Collection<? extends OmegaMembershipOracle<S, I, D>> oracles, @NonNegative int minBatchSize, PoolPolicy policy); @Override void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries); @Override MembershipOracle<I, D> getMembershipOracle(); @Override boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2); }### Answer: @Test public void testSingleMethods() { final ParallelOmegaOracle<?, Integer, TestOutput> oracle = getBuilder().create(); Assert.assertThrows(OmegaException.class, oracle::getMembershipOracle); Assert.assertThrows(OmegaException.class, () -> oracle.isSameState(null, null, null, null)); }
### Question: DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries) { processBatch(omegaQueries); } DynamicParallelOmegaOracle(Supplier<? extends OmegaMembershipOracle<S, I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); @Override void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries); @Override MembershipOracle<I, D> getMembershipOracle(); @Override boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2); }### Answer: @Test(dataProvider = "policies", dataProviderClass = Utils.class, timeOut = 2000) public void testThreadCreation(PoolPolicy poolPolicy) { final List<AnswerOnceQuery<Void>> queries = createQueries(10); final int expectedThreads = queries.size(); final CountDownLatch latch = new CountDownLatch(expectedThreads); final NullOracle[] oracles = new NullOracle[expectedThreads]; for (int i = 0; i < expectedThreads; i++) { oracles[i] = new NullOracle() { @Override public void processQueries(Collection<? extends OmegaQuery<Void, Void>> queries) { try { latch.countDown(); latch.await(); } catch (InterruptedException e) { throw new IllegalStateException(e); } super.processQueries(queries); } }; } final ParallelOmegaOracle<?, Void, Void> oracle = ParallelOracleBuilders.newDynamicParallelOmegaOracle(oracles[0], Arrays.copyOfRange(oracles, 1, oracles.length)) .withBatchSize(1) .withPoolSize(oracles.length) .withPoolPolicy(poolPolicy) .create(); try { oracle.processQueries(queries); } finally { oracle.shutdown(); } } @Test(dataProvider = "policies", dataProviderClass = Utils.class, timeOut = 2000) public void testThreadScheduling(PoolPolicy poolPolicy) { final List<AnswerOnceQuery<Void>> queries = createQueries(10); final CountDownLatch latch = new CountDownLatch(queries.size() - 1); final NullOracle awaitingOracle = new NullOracle() { @Override public void processQueries(Collection<? extends OmegaQuery<Void, Void>> queries) { try { latch.await(); } catch (InterruptedException e) { throw new IllegalStateException(e); } super.processQueries(queries); } }; final NullOracle countDownOracle = new NullOracle() { @Override public void processQueries(Collection<? extends OmegaQuery<Void, Void>> queries) { latch.countDown(); super.processQueries(queries); } }; final ParallelOmegaOracle<?, Void, Void> oracle = ParallelOracleBuilders.newDynamicParallelOmegaOracle(awaitingOracle, countDownOracle) .withPoolSize(2) .withPoolPolicy(poolPolicy) .create(); try { oracle.processQueries(queries); } finally { oracle.shutdown(); } }
### Question: DynamicParallelOmegaOracle extends AbstractDynamicBatchProcessor<OmegaQuery<I, D>, OmegaMembershipOracle<S, I, D>> implements ParallelOmegaOracle<S, I, D> { @Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); } DynamicParallelOmegaOracle(Supplier<? extends OmegaMembershipOracle<S, I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); @Override void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries); @Override MembershipOracle<I, D> getMembershipOracle(); @Override boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2); }### Answer: @Test public void testSingleMethods() { final ParallelOmegaOracle<?, Void, Void> oracle = getBuilder().create(); Assert.assertThrows(OmegaException.class, oracle::getMembershipOracle); Assert.assertThrows(OmegaException.class, () -> oracle.isSameState(null, null, null, null)); }
### Question: DynamicParallelOracle extends AbstractDynamicBatchProcessor<Query<I, D>, MembershipOracle<I, D>> implements ParallelOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { processBatch(queries); } DynamicParallelOracle(Supplier<? extends MembershipOracle<I, D>> oracleSupplier, @NonNegative int batchSize, ExecutorService executor); @Override void processQueries(Collection<? extends Query<I, D>> queries); }### Answer: @Test(dataProvider = "policies", dataProviderClass = Utils.class, timeOut = 2000) public void testThreadCreation(PoolPolicy poolPolicy) { final List<AnswerOnceQuery<Void>> queries = createQueries(10); final int expectedThreads = queries.size(); final CountDownLatch latch = new CountDownLatch(expectedThreads); final NullOracle[] oracles = new NullOracle[expectedThreads]; for (int i = 0; i < expectedThreads; i++) { oracles[i] = new NullOracle() { @Override public void processQueries(Collection<? extends Query<Void, Void>> queries) { try { latch.countDown(); latch.await(); } catch (InterruptedException e) { throw new IllegalStateException(e); } super.processQueries(queries); } }; } final ParallelOracle<Void, Void> oracle = ParallelOracleBuilders.newDynamicParallelOracle(oracles[0], Arrays.copyOfRange( oracles, 1, oracles.length)) .withBatchSize(1) .withPoolSize(oracles.length) .withPoolPolicy(poolPolicy) .create(); try { oracle.processQueries(queries); } finally { oracle.shutdown(); } } @Test(dataProvider = "policies", dataProviderClass = Utils.class, timeOut = 2000) public void testThreadScheduling(PoolPolicy poolPolicy) { final List<AnswerOnceQuery<Void>> queries = createQueries(10); final CountDownLatch latch = new CountDownLatch(queries.size() - 1); final NullOracle awaitingOracle = new NullOracle() { @Override public void processQueries(Collection<? extends Query<Void, Void>> queries) { try { latch.await(); } catch (InterruptedException e) { throw new IllegalStateException(e); } super.processQueries(queries); } }; final NullOracle countDownOracle = new NullOracle() { @Override public void processQueries(Collection<? extends Query<Void, Void>> queries) { latch.countDown(); super.processQueries(queries); } }; final ParallelOracle<Void, Void> oracle = ParallelOracleBuilders.newDynamicParallelOracle(awaitingOracle, countDownOracle) .withPoolSize(2) .withPoolPolicy(poolPolicy) .create(); try { oracle.processQueries(queries); } finally { oracle.shutdown(); } }
### Question: HistogramOracle implements StatisticOracle<I, D> { @Override public final void processQueries(Collection<? extends Query<I, D>> queries) { for (Query<I, D> q : queries) { this.dataSet.addDataPoint((long) q.getInput().size()); } nextOracle.processQueries(queries); } HistogramOracle(MembershipOracle<I, D> next, String name); @Override final void processQueries(Collection<? extends Query<I, D>> queries); @Override final HistogramDataSet getStatisticalData(); @Override final void setNext(final MembershipOracle<I, D> next); }### Answer: @Test(dependsOnMethods = "testInitialState") public void testFirstQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2); oracle.processQueries(queries); verifyCounts(2, 0, 0, 0); } @Test(dependsOnMethods = "testFirstQueryBatch") public void testEmptyQueryBatch() { Collection<Query<Integer, Word<Character>>> noQueries = Collections.emptySet(); oracle.processQueries(noQueries); verifyCounts(2, 0, 0, 0); } @Test(dependsOnMethods = "testEmptyQueryBatch") public void testSecondQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2, 5, TestQueries.INPUTS); oracle.processQueries(queries); verifyCounts(4, 10, 2.5, 0); }
### Question: HistogramOracle implements StatisticOracle<I, D> { @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } HistogramOracle(MembershipOracle<I, D> next, String name); @Override final void processQueries(Collection<? extends Query<I, D>> queries); @Override final HistogramDataSet getStatisticalData(); @Override final void setNext(final MembershipOracle<I, D> next); }### Answer: @Test(dependsOnMethods = "testSecondQueryBatch") public void testSummary() throws IOException { final String details = oracle.getStatisticalData().getDetails(); final String summary = oracle.getStatisticalData().getSummary(); try (InputStream detailStream = HistogramOracleTest.class.getResourceAsStream("/histogram_details.txt"); InputStream summaryStream = HistogramOracleTest.class.getResourceAsStream("/histogram_summary.txt")) { final String expectedDetail = CharStreams.toString(IOUtil.asBufferedUTF8Reader(detailStream)); final String expectedSummary = CharStreams.toString(IOUtil.asBufferedUTF8Reader(summaryStream)); Assert.assertEquals(details, expectedDetail); Assert.assertEquals(summary, expectedSummary); } } @Test public void testGetName() { Assert.assertEquals(oracle.getStatisticalData().getName(), COUNTER_NAME); }
### Question: SuffixASCIIWriter extends AbstractObservationTableWriter<I, D> { @Override public void write(ObservationTable<? extends I, ? extends D> table, Appendable out) throws IOException { List<? extends Word<? extends I>> suffixes = table.getSuffixes(); StringBuilder sb = new StringBuilder(); boolean first = true; for (Word<? extends I> word : suffixes) { if (first) { first = false; } else { sb.append(WORD_DELIMITER); } String stringRepresentation = wordToString(word); if (stringRepresentation.contains(WORD_DELIMITER)) { throw new IllegalArgumentException( "Delimiter '" + WORD_DELIMITER + "' must not be used in symbol names. " + "Symbol containing the delimiter was '" + stringRepresentation + '\''); } else { sb.append(stringRepresentation); } } out.append(sb.toString()); } SuffixASCIIWriter(); @Override void write(ObservationTable<? extends I, ? extends D> table, Appendable out); }### Answer: @Test public void testWrite() { SuffixASCIIWriter<String, String> writer = new SuffixASCIIWriter<>(); ObservationTable<String, String> ot = ObservationTableSource.otWithFourSuffixes(); Assert.assertEquals(OTUtils.toString(ot, writer), ";A;B;A,B"); }
### Question: CounterOracle implements StatisticOracle<I, D> { public long getCount() { return counter.getCount(); } CounterOracle(MembershipOracle<I, D> nextOracle, String name); @Override void processQueries(Collection<? extends Query<I, D>> queries); @Override Counter getStatisticalData(); Counter getCounter(); long getCount(); @Override void setNext(MembershipOracle<I, D> next); }### Answer: @Test public void testInitialState() { Assert.assertEquals(oracle.getCount(), 0L); }
### Question: CounterOracle implements StatisticOracle<I, D> { public Counter getCounter() { return this.counter; } CounterOracle(MembershipOracle<I, D> nextOracle, String name); @Override void processQueries(Collection<? extends Query<I, D>> queries); @Override Counter getStatisticalData(); Counter getCounter(); long getCount(); @Override void setNext(MembershipOracle<I, D> next); }### Answer: @Test public void testGetName() { Assert.assertEquals(oracle.getCounter().getName(), COUNTER_NAME); }
### Question: JointCounterOracle implements MembershipOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { queryCounter.addAndGet(queries.size()); for (Query<I, D> qry : queries) { symbolCounter.addAndGet(qry.getInput().length()); } delegate.processQueries(queries); } JointCounterOracle(MembershipOracle<I, D> delegate); @Override void processQueries(Collection<? extends Query<I, D>> queries); long getQueryCount(); long getSymbolCount(); }### Answer: @Test(dependsOnMethods = "testInitialState") public void testFirstQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2); oracle.processQueries(queries); verifyCounts(2, 0); } @Test(dependsOnMethods = "testFirstQueryBatch") public void testEmptyQueryBatch() { Collection<Query<Integer, Word<Character>>> noQueries = Collections.emptySet(); oracle.processQueries(noQueries); verifyCounts(2, 0); } @Test(dependsOnMethods = "testEmptyQueryBatch") public void testSecondQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2, 5, TestQueries.INPUTS); oracle.processQueries(queries); verifyCounts(4, 10); }
### Question: MealyDHC implements MealyLearner<I, O>, AccessSequenceTransformer<I>, GlobalSuffixLearnerMealy<I, O>, SupportsGrowingAlphabet<I>, Resumable<MealyDHCState<I, O>> { @Override public CompactMealy<I, O> getHypothesisModel() { checkInternalState(); return hypothesis; } MealyDHC(Alphabet<I> alphabet, MembershipOracle<I, Word<O>> oracle); @GenerateBuilder(defaults = BuilderDefaults.class, builderFinal = false) MealyDHC(Alphabet<I> alphabet, MembershipOracle<I, Word<O>> oracle, GlobalSuffixFinder<? super I, ? super Word<O>> suffixFinder, Collection<? extends Word<I>> initialSplitters); @Override Collection<Word<I>> getGlobalSuffixes(); @Override boolean addGlobalSuffixes(Collection<? extends Word<I>> newGlobalSuffixes); @Override void startLearning(); @Override boolean refineHypothesis(DefaultQuery<I, Word<O>> ceQuery); @Override CompactMealy<I, O> getHypothesisModel(); @Override void addAlphabetSymbol(I symbol); @Override MealyDHCState<I, O> suspend(); @Override void resume(final MealyDHCState<I, O> state); @Override Word<I> transformAccessSequence(Word<I> word); @Override boolean isAccessSequence(Word<I> word); }### Answer: @Test(expectedExceptions = Exception.class) public void testMealyDHCInternalSate() { ExampleStack stackExample = ExampleStack.createExample(); MealyMachine<?, ExampleStack.Input, ?, ExampleStack.Output> fm = stackExample.getReferenceAutomaton(); Alphabet<ExampleStack.Input> alphabet = stackExample.getAlphabet(); MealySimulatorOracle<ExampleStack.Input, ExampleStack.Output> simoracle = new MealySimulatorOracle<>(fm); MealyDHC<ExampleStack.Input, ExampleStack.Output> dhc = new MealyDHC<>(alphabet, simoracle); dhc.getHypothesisModel(); }
### Question: ADTHypothesis extends AbstractFastMutableDet<ADTState<I, O>, I, ADTTransition<I, O>, Void, O> implements MutableMealyMachine<ADTState<I, O>, I, ADTTransition<I, O>, O>, AccessSequenceTransformer<I> { @Override public void setTransition(final ADTState<I, O> state, I input, final ADTTransition<I, O> transition) { final ADTTransition<I, O> oldTrans = getTransition(state, input); if (oldTrans != null) { oldTrans.getTarget().getIncomingTransitions().remove(oldTrans); } super.setTransition(state, input, transition); if (transition != null) { transition.setSource(state); transition.setInput(input); } } ADTHypothesis(final Alphabet<I> alphabet); @Override ADTState<I, O> getSuccessor(final ADTTransition<I, O> transition); ADTTransition<I, O> createOpenTransition(final ADTState<I, O> source, final I input, final ADTNode<ADTState<I, O>, I, O> siftTarget); @Override void setTransition(final ADTState<I, O> state, I input, final ADTTransition<I, O> transition); @Override ADTTransition<I, O> createTransition(final ADTState<I, O> successor, final O properties); @Override void setTransitionOutput(final ADTTransition<I, O> transition, final O output); @Override O getTransitionOutput(final ADTTransition<I, O> transition); @SuppressWarnings("nullness") // hypothesis is always complete @Override Word<I> transformAccessSequence(final Word<I> word); @SuppressWarnings("nullness") // hypothesis is always complete @Override boolean isAccessSequence(final Word<I> word); }### Answer: @Test public void testAutomaton() { final int states = 10; final Alphabet<Character> alphabet = Alphabets.characters('a', 'd'); final ADTHypothesis<Character, Integer> automaton = new ADTHypothesis<>(alphabet); automaton.addInitialState(); for (int i = 1; i < states; i++) { automaton.addState(); } Assert.assertEquals(states, automaton.size()); automaton.getStates().forEach(x -> Assert.assertTrue(x.getIncomingTransitions().isEmpty())); final StateIDs<ADTState<Character, Integer>> stateIds = automaton.stateIDs(); for (int s = 0; s < automaton.size(); s++) { for (final Character i : alphabet) { automaton.addTransition(stateIds.getState(s), i, automaton.getInitialState(), 0); } } Assert.assertEquals(states * alphabet.size(), automaton.getInitialState().getIncomingTransitions().size()); final ADTState<Character, Integer> s1 = stateIds.getState(1), s2 = stateIds.getState(2), s3 = stateIds.getState(3); automaton.removeAllTransitions(s1); Assert.assertEquals((states - 1) * alphabet.size(), automaton.getInitialState().getIncomingTransitions().size()); automaton.removeAllTransitions(s2, alphabet.getSymbol(0)); Assert.assertEquals((states - 1) * alphabet.size() - 1, automaton.getInitialState().getIncomingTransitions().size()); automaton.addTransition(s2, alphabet.getSymbol(0), s1, 0); for (int i = 1; i < alphabet.size(); i++) { ADTTransition<Character, Integer> transition = automaton.getTransition(s2, alphabet.getSymbol(i)); transition.setTarget(s1); } Assert.assertEquals(alphabet.size(), s1.getIncomingTransitions().size()); for (int i = 0; i < alphabet.size(); i++) { automaton.setTransition(s3, alphabet.getSymbol(i), s1, 0); } Assert.assertEquals(alphabet.size() * 2, s1.getIncomingTransitions().size()); }
### Question: AbstractBFEmptinessOracle extends AbstractBFOracle<A, I, D> implements EmptinessOracle<A, I, D> { @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { return super.findCounterExample(hypothesis, inputs); } protected AbstractBFEmptinessOracle(MembershipOracle<I, D> membershipOracle, double multiplier); @Override boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, @Nullable D output); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }### Answer: @Test public void testFindCounterExample() { final DefaultQuery<Character, D> cex = bfeo.findCounterExample(automaton, ALPHABET); Assert.assertEquals(cex, query); }
### Question: AbstractBFEmptinessOracle extends AbstractBFOracle<A, I, D> implements EmptinessOracle<A, I, D> { @Override public boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, @Nullable D output) { return EmptinessOracle.super.isCounterExample(hypothesis, inputs, output); } protected AbstractBFEmptinessOracle(MembershipOracle<I, D> membershipOracle, double multiplier); @Override boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, @Nullable D output); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }### Answer: @Test public void testIsCounterExample() { bfeo.isCounterExample(automaton, query.getInput(), query.getOutput()); }
### Question: DisproveFirstOracle implements BlackBoxOracle<A, I, D> { @Override public List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles() { return propertyOracles; } DisproveFirstOracle(); DisproveFirstOracle(PropertyOracle<I, ? super A, ?, D> propertyOracle); DisproveFirstOracle(Collection<? extends PropertyOracle<I, ? super A, ?, D>> propertyOracles); @Override List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles(); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }### Answer: @Test public void testGetPropertyOracles() { Assert.assertEquals(oracle.getPropertyOracles().size(), 2); }
### Question: DisproveFirstOracle implements BlackBoxOracle<A, I, D> { @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { for (PropertyOracle<I, ? super A, ?, D> po : propertyOracles) { if (!po.isDisproved()) { po.disprove(hypothesis, inputs); } } for (PropertyOracle<I, ? super A, ?, D> po : propertyOracles) { if (!po.isDisproved()) { final DefaultQuery<I, D> ce = po.doFindCounterExample(hypothesis, inputs); if (ce != null) { assert isCounterExample(hypothesis, ce.getInput(), ce.getOutput()); return ce; } } } return null; } DisproveFirstOracle(); DisproveFirstOracle(PropertyOracle<I, ? super A, ?, D> propertyOracle); DisproveFirstOracle(Collection<? extends PropertyOracle<I, ? super A, ?, D>> propertyOracles); @Override List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles(); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }### Answer: @Test public void testFindCounterExample() { final DefaultQuery<Boolean, Boolean> ce = oracle.findCounterExample(automaton, inputs); Assert.assertEquals(ce, query); Mockito.verify(po1, Mockito.times(1)).disprove(automaton, inputs); Mockito.verify(po2).disprove(automaton, inputs); Mockito.verify(po2, Mockito.never()).doFindCounterExample(automaton, inputs); }
### Question: AbstractBFInclusionOracle extends AbstractBFOracle<A, I, D> implements InclusionOracle<A, I, D> { @Override public boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, D output) { return InclusionOracle.super.isCounterExample(hypothesis, inputs, output); } AbstractBFInclusionOracle(MembershipOracle<I, D> membershipOracle, double multiplier); @Override boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, D output); @Override @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs); }### Answer: @Test public void testIsCounterExample() { Assert.assertTrue(bfio.isCounterExample(automaton, query.getInput(), query.getOutput())); }
### Question: Entry implements ContentHolder<T> { public static Entry<Void> ofDirectory(Revision revision, String path) { return new Entry<>(revision, path, EntryType.DIRECTORY, null); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); static Entry<Void> ofDirectory(Revision revision, String path); static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content); static Entry<JsonNode> ofJson(Revision revision, String path, String content); static Entry<String> ofText(Revision revision, String path, String content); static Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content); Revision revision(); String path(); boolean hasContent(); void ifHasContent(Consumer<? super T> consumer); @Override EntryType type(); @Override T content(); @Override String contentAsText(); @Override String contentAsPrettyText(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test void ofDirectory() throws Exception { final Entry<Void> e = Entry.ofDirectory(new Revision(1), "/"); assertThat(e.revision()).isEqualTo(new Revision(1)); assertThat(e.hasContent()).isFalse(); assertThatThrownBy(e::content).isInstanceOf(EntryNoContentException.class); assertThatThrownBy(e::contentAsJson).isInstanceOf(EntryNoContentException.class); assertThatThrownBy(e::contentAsText).isInstanceOf(EntryNoContentException.class); assertThatThrownBy(e::contentAsPrettyText).isInstanceOf(EntryNoContentException.class); assertThatThrownBy(() -> e.contentAsJson(JsonNode.class)).isInstanceOf(EntryNoContentException.class); final Entry<Void> e2 = Entry.ofDirectory(new Revision(1), "/"); assertThat(e).isEqualTo(e2); assertThat(e.hashCode()).isEqualTo(e2.hashCode()); assertThat(e).isNotEqualTo(Entry.ofDirectory(new Revision(2), "/")); assertThat(e).isNotEqualTo(Entry.ofDirectory(new Revision(1), "/foo")); final Entry<String> e3 = Entry.ofText(new Revision(1), "/a.txt", "foo"); assertThat(e).isNotEqualTo(e3); assertThat(e.hashCode()).isNotEqualTo(e3.hashCode()); final Entry<JsonNode> e4 = Entry.ofJson(new Revision(1), "/a.json", "{ \"foo\": \"bar\" }"); assertThat(e).isNotEqualTo(e4); assertThat(e.hashCode()).isNotEqualTo(e4.hashCode()); }
### Question: CachingRepository implements Repository { @Override public CompletableFuture<Map<String, Entry<?>>> find(Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { requireNonNull(revision, "revision"); requireNonNull(pathPattern, "pathPattern"); requireNonNull(options, "options"); final Revision normalizedRevision = normalizeNow(revision); return cache.get(new CacheableFindCall(repo, normalizedRevision, pathPattern, options)); } CachingRepository(Repository repo, RepositoryCache cache); @Override long creationTimeMillis(); @Override Author author(); @Override CompletableFuture<Entry<T>> getOrNull(Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> find(Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Change<?>> diff(Revision from, Revision to, Query<?> query); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); @Override Project parent(); @Override String name(); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit(Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<MergedEntry<T>> mergeFiles(Revision revision, MergeQuery<T> query); @Override String toString(); }### Answer: @Test void find() { final Repository repo = setMockNames(newCachingRepo()); final Map<String, Entry<?>> entries = ImmutableMap.of("/baz.txt", Entry.ofText(new Revision(10), "/baz.txt", "qux")); doReturn(new Revision(10)).when(delegateRepo).normalizeNow(new Revision(10)); doReturn(new Revision(10)).when(delegateRepo).normalizeNow(HEAD); when(delegateRepo.find(any(), any(), any())).thenReturn(completedFuture(entries)); assertThat(repo.find(HEAD, "/", ImmutableMap.of()).join()).isEqualTo(entries); verify(delegateRepo).find(new Revision(10), "/", ImmutableMap.of()); verifyNoMoreInteractions(delegateRepo); clearInvocations(delegateRepo); assertThat(repo.find(HEAD, "/", ImmutableMap.of()).join()).isEqualTo(entries); assertThat(repo.find(new Revision(10), "/", ImmutableMap.of()).join()).isEqualTo(entries); verify(delegateRepo, never()).find(any(), any(), any()); verifyNoMoreInteractions(delegateRepo); }
### Question: CachingRepository implements Repository { @Override public Revision normalizeNow(Revision revision) { return repo.normalizeNow(revision); } CachingRepository(Repository repo, RepositoryCache cache); @Override long creationTimeMillis(); @Override Author author(); @Override CompletableFuture<Entry<T>> getOrNull(Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> find(Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Change<?>> diff(Revision from, Revision to, Query<?> query); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); @Override Project parent(); @Override String name(); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit(Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<MergedEntry<T>> mergeFiles(Revision revision, MergeQuery<T> query); @Override String toString(); }### Answer: @Test void metrics() { final MeterRegistry meterRegistry = PrometheusMeterRegistries.newRegistry(); final Repository repo = newCachingRepo(meterRegistry); final Map<String, Double> meters = MoreMeters.measureAll(meterRegistry); assertThat(meters).containsKeys("cache.load#count{cache=repository,result=success}"); assertThat(repo.normalizeNow(HEAD)).isNotEqualTo(""); }
### Question: TagUtil { static String byteHexDirName(int majorRevision) { if (majorRevision <= 0) { throw new IllegalArgumentException("invalid majorRevision " + majorRevision + " (expected: > 0)"); } final StringBuilder sb = new StringBuilder(16); final int shift = 8; do { sb.append(TABLE[majorRevision & 0xFF]); majorRevision >>>= shift; } while (majorRevision != 0); return sb.toString(); } private TagUtil(); }### Answer: @Test void testByteHexDirName() { assertThat(TagUtil.byteHexDirName(0x00000001)).isEqualTo("01/"); assertThat(TagUtil.byteHexDirName(0x00000b0a)).isEqualTo("0a/0b/"); assertThat(TagUtil.byteHexDirName(0x000c0b0a)).isEqualTo("0a/0b/0c/"); assertThat(TagUtil.byteHexDirName(0x0d0c0b0a)).isEqualTo("0a/0b/0c/0d/"); } @Test void testByteHexDirNameException() { assertThatIllegalArgumentException() .isThrownBy(() -> TagUtil.byteHexDirName(0)); assertThatIllegalArgumentException() .isThrownBy(() -> TagUtil.byteHexDirName(-1)); }
### Question: JsonPatch implements JsonSerializable { public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } @JsonCreator JsonPatch(final List<JsonPatchOperation> operations); static JsonPatch fromJson(final JsonNode node); static JsonPatch generate(final JsonNode source, final JsonNode target, ReplaceMode replaceMode); boolean isEmpty(); List<JsonPatchOperation> operations(); JsonNode apply(final JsonNode node); ArrayNode toJson(); @Override String toString(); @Override void serialize(final JsonGenerator jgen, final SerializerProvider provider); @Override void serializeWithType(final JsonGenerator jgen, final SerializerProvider provider, final TypeSerializer typeSer); }### Answer: @Test void cannotPatchNull() { final JsonPatch patch = new JsonPatch(ImmutableList.of(op1, op2)); assertThatNullPointerException() .isThrownBy(() -> patch.apply(null)); } @Test void operationsAreCalledInOrder() { final JsonNode node1 = FACTORY.textNode("hello"); final JsonNode node2 = FACTORY.textNode("world"); when(op1.apply(node1)).thenReturn(node2); final JsonPatch patch = new JsonPatch(ImmutableList.of(op1, op2)); final ArgumentCaptor<JsonNode> captor = ArgumentCaptor.forClass(JsonNode.class); patch.apply(node1); verify(op1, only()).apply(same(node1)); verify(op2, only()).apply(captor.capture()); assertThat(captor.getValue()).isSameAs(node2); } @Test void whenOneOperationFailsNextOperationIsNotCalled() { final String message = "foo"; when(op1.apply(any(JsonNode.class))) .thenThrow(new JsonPatchException(message)); final JsonPatch patch = new JsonPatch(ImmutableList.of(op1, op2)); assertThatThrownBy(() -> patch.apply(FACTORY.nullNode())) .isInstanceOf(JsonPatchException.class) .hasMessage(message); verifyNoMoreInteractions(op2); }
### Question: GitRepository implements Repository { @Override public CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "previewDiff", baseRevision); return blockingPreviewDiff(baseRevision, changes); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }### Answer: @Test void testPreviewDiff() { final Map<String, Change<?>> changeMap = repo.previewDiff(HEAD, jsonUpserts[0]).join(); assertThat(changeMap).containsEntry(jsonPaths[0], jsonUpserts[0]); assertThatThrownBy(() -> repo.previewDiff(HEAD, jsonPatches[1]).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); assertThatThrownBy(() -> repo.previewDiff(HEAD, Change.ofRemoval(jsonPaths[0])).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); final List<Change<?>> changes = Arrays.asList(jsonUpserts[0], jsonPatches[1], jsonPatches[2], Change.ofRename(jsonPaths[0], jsonPaths[1]), Change.ofRemoval(jsonPaths[1])); Map<String, Change<?>> returnedChangeMap = repo.previewDiff(HEAD, changes).join(); assertThat(returnedChangeMap).isEmpty(); assertThatThrownBy(() -> repo.previewDiff(new Revision(Integer.MAX_VALUE), changes).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(RevisionNotFoundException.class); assertThat(repo.previewDiff(new Revision(-1), Collections.emptyList()).join()).isEmpty(); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonPatches[0], jsonPatches[1]).join(); returnedChangeMap = repo.previewDiff(HEAD, jsonUpserts[0]).join(); assertThat(returnedChangeMap.get(jsonPaths[0]).type()).isEqualTo(ChangeType.APPLY_JSON_PATCH); }
### Question: GitRepository implements Repository { @Override public CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "find", revision, pathPattern, options); return blockingFind(revision, pathPattern, options); }, repositoryWorker); } @VisibleForTesting GitRepository(Project parent, File repoDir, Executor repositoryWorker, long creationTimeMillis, Author author); GitRepository(Project parent, File repoDir, GitRepositoryFormat format, Executor repositoryWorker, long creationTimeMillis, Author author, @Nullable RepositoryCache cache); GitRepository(Project parent, File repoDir, Executor repositoryWorker, @Nullable RepositoryCache cache); @Override Project parent(); @Override String name(); GitRepositoryFormat format(); boolean needsMigration(GitRepositoryFormat preferredFormat); @Override Revision normalizeNow(Revision revision); @Override RevisionRange normalizeNow(Revision from, Revision to); @Override CompletableFuture<Map<String, Entry<?>>> find( Revision revision, String pathPattern, Map<FindOption<?>, ?> options); @Override CompletableFuture<List<Commit>> history( Revision from, Revision to, String pathPattern, int maxCommits); @Override CompletableFuture<Map<String, Change<?>>> diff(Revision from, Revision to, String pathPattern); @Override CompletableFuture<Map<String, Change<?>>> previewDiff(Revision baseRevision, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes); @Override CompletableFuture<Revision> findLatestRevision(Revision lastKnownRevision, String pathPattern); @Override CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern); void cloneTo(File newRepoDir); void cloneTo(File newRepoDir, BiConsumer<Integer, Integer> progressListener); void cloneTo(File newRepoDir, GitRepositoryFormat format); void cloneTo(File newRepoDir, GitRepositoryFormat format, BiConsumer<Integer, Integer> progressListener); @Override String toString(); }### Answer: @Test void testFindNone() { assertThat(repo.find(HEAD, "/non-existent").join()).isEmpty(); assertThat(repo.find(HEAD, "non-existent").join()).isEmpty(); } @Test void testFind_invalidPathPattern() { final String pattern = "a'\"><img src=1 onerror=alert(document.domain)>"; assertThatThrownBy(() -> repo.find(HEAD, pattern).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(IllegalArgumentException.class); }
### Question: TokenlessClientLogger extends SimpleDecoratingHttpService { @Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final String authorization = req.headers().get(HttpHeaderNames.AUTHORIZATION); if (authorization == null \|\| !PATTERN.matcher(authorization).matches()) { final InetSocketAddress raddr = ctx.remoteAddress(); final String ip = raddr.getAddress().getHostAddress(); final Instant now = Instant.now(clock); final Instant lastReport = reportedAddresses.putIfAbsent(ip, now); final boolean report; if (lastReport == null) { report = true; } else if (ChronoUnit.DAYS.between(lastReport, now) >= 1) { report = reportedAddresses.replace(ip, lastReport, now); } else { report = false; } if (report) { report(raddr.getHostString(), ip); } } return unwrap().serve(ctx, req); } TokenlessClientLogger(HttpService delegate); @VisibleForTesting TokenlessClientLogger(HttpService delegate, Clock clock); @Override HttpResponse serve(ServiceRequestContext ctx, HttpRequest req); }### Answer: @Test void testWithToken() throws Exception { final MockTokenlessClientLogger logger = new MockTokenlessClientLogger(); final ServiceRequestContext ctx = mock(ServiceRequestContext.class); final HttpRequest req = newRequestWithToken(); logger.serve(ctx, req); assertThat(logger.hostname).isNull(); assertThat(logger.ip).isNull(); verify(delegate, times(1)).serve(ctx, req); verify(clock, never()).instant(); } @Test void testWithoutToken() throws Exception { final MockTokenlessClientLogger logger = new MockTokenlessClientLogger(); final Instant startTime = Instant.now(); when(clock.instant()).thenReturn(startTime); final ServiceRequestContext ctx = newContext("foo", "192.168.0.1"); final HttpRequest req = newRequestWithoutToken(); logger.serve(ctx, req); assertThat(logger.hostname).isEqualTo("foo"); assertThat(logger.ip).isEqualTo("192.168.0.1"); verify(delegate, times(1)).serve(ctx, req); final ServiceRequestContext ctx2 = newContext("bar", "192.168.0.1"); final HttpRequest req2 = newRequestWithoutToken(); when(clock.instant()).thenReturn(startTime.plus(30, ChronoUnit.MINUTES)); logger.serve(ctx2, req2); assertThat(logger.hostname).isNull(); assertThat(logger.ip).isNull(); verify(delegate, times(1)).serve(ctx2, req2); final ServiceRequestContext ctx3 = newContext("baz", "192.168.0.1"); final HttpRequest req3 = newRequestWithoutToken(); when(clock.instant()).thenReturn(startTime.plus(1, ChronoUnit.DAYS)); logger.serve(ctx3, req3); assertThat(logger.hostname).isEqualTo("baz"); assertThat(logger.ip).isEqualTo("192.168.0.1"); verify(delegate, times(1)).serve(ctx3, req3); final ServiceRequestContext ctx4 = newContext("qux", "192.168.0.2"); final HttpRequest req4 = newRequestWithoutToken(); logger.serve(ctx4, req4); assertThat(logger.hostname).isEqualTo("qux"); assertThat(logger.ip).isEqualTo("192.168.0.2"); verify(delegate, times(1)).serve(ctx4, req4); }
### Question: PublicKeyMirrorCredential extends AbstractMirrorCredential { @Nullable public byte[] passphrase() { if (passphrase == null) { return null; } else { return passphrase.clone(); } } @JsonCreator PublicKeyMirrorCredential(@JsonProperty("id") @Nullable String id, @JsonProperty("hostnamePatterns") @Nullable @JsonDeserialize(contentAs = Pattern.class) Iterable<Pattern> hostnamePatterns, @JsonProperty("username") String username, @JsonProperty("publicKey") String publicKey, @JsonProperty("privateKey") String privateKey, @JsonProperty("passphrase") @Nullable String passphrase); PublicKeyMirrorCredential(@Nullable String id, @Nullable Iterable<Pattern> hostnamePatterns, String username, byte[] publicKey, byte[] privateKey, @Nullable byte[] passphrase); String username(); byte[] publicKey(); byte[] privateKey(); @Nullable byte[] passphrase(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test void testBase64Passphrase() { final PublicKeyMirrorCredential c = new PublicKeyMirrorCredential( null, null, USERNAME, PUBLIC_KEY, PRIVATE_KEY, PASSPHRASE_BASE64); assertThat(c.passphrase()).isEqualTo(PASSPHRASE.getBytes(StandardCharsets.UTF_8)); }
### Question: ExpiredSessionDeletingSessionManager extends ForwardingSessionManager { @Override public CompletableFuture<Session> get(String sessionId) { return super.get(sessionId).thenApply(session -> { if (session != null) { if (Instant.now().isBefore(session.expirationTime())) { return session; } delete(sessionId); } return null; }); } ExpiredSessionDeletingSessionManager(SessionManager delegate); @Override CompletableFuture<Session> get(String sessionId); }### Answer: @Test void shouldReturnNonNull() { final Session expiredAfterOneHour = createSession(Instant.now().plus(1, ChronoUnit.HOURS)); final SessionManager delegate = mock(SessionManager.class); when(delegate.get(any())).thenReturn(CompletableFuture.completedFuture(expiredAfterOneHour)); final ExpiredSessionDeletingSessionManager manager = new ExpiredSessionDeletingSessionManager(delegate); assertThat(manager.get("id").join()).isEqualTo(expiredAfterOneHour); } @Test void shouldReturnNull() { final Session expiredSession = createSession(Instant.EPOCH); final SessionManager delegate = mock(SessionManager.class); when(delegate.get(any())).thenReturn(CompletableFuture.completedFuture(expiredSession)); final ExpiredSessionDeletingSessionManager manager = new ExpiredSessionDeletingSessionManager(delegate); assertThat(manager.get("id").join()).isNull(); }
### Question: CentralDogmaAuthFailureHandler implements AuthFailureHandler { @Override public HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause) throws Exception { if (cause != null) { if (!(cause instanceof ShuttingDownException)) { logger.warn("Unexpected exception during authorization:", cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.INTERNAL_SERVER_ERROR, cause); } return HttpApiUtil.newResponse(ctx, HttpStatus.UNAUTHORIZED, AUTHORIZATION_EXCEPTION); } @Override HttpResponse authFailed(HttpService delegate, ServiceRequestContext ctx, HttpRequest req, @Nullable Throwable cause); }### Answer: @Test void shuttingDown() throws Exception { final AggregatedHttpResponse res = handler.authFailed(delegate, ctx, req, new ShuttingDownException()) .aggregate().join(); assertThat(res.status()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR); assertThat(res.contentType()).isEqualTo(MediaType.JSON_UTF_8); assertThatJson(res.contentUtf8()).isEqualTo( '{' + " \"exception\": \"com.linecorp.centraldogma.common.ShuttingDownException\"," + " \"message\":\"\"" + '}'); } @Test void failure() throws Exception { final AggregatedHttpResponse res = handler.authFailed(delegate, ctx, req, new Exception("oops")) .aggregate().join(); assertThat(res.status()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR); assertThat(res.contentType()).isEqualTo(MediaType.JSON_UTF_8); assertThatJson(res.contentUtf8()).isEqualTo( '{' + " \"exception\": \"java.lang.Exception\"," + " \"message\":\"oops\"" + '}'); } @Test void incorrectToken() throws Exception { final AggregatedHttpResponse res = handler.authFailed(delegate, ctx, req, null) .aggregate().join(); assertThat(res.status()).isEqualTo(HttpStatus.UNAUTHORIZED); assertThat(res.contentType()).isEqualTo(MediaType.JSON_UTF_8); assertThatJson(res.contentUtf8()).isEqualTo( '{' + " \"exception\": \"com.linecorp.centraldogma.common.AuthorizationException\"," + " \"message\":\"\"" + '}'); }
### Question: Util { public static String validateFilePath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidFilePath(path), "%s: %s (expected: %s)", paramName, path, FILE_PATH_PATTERN); return path; } private Util(); static String validateFileName(String name, String paramName); static boolean isValidFileName(String name); static String validateFilePath(String path, String paramName); static boolean isValidFilePath(String path); static String validateJsonFilePath(String path, String paramName); static boolean isValidJsonFilePath(String path); static String validateJsonPath(String jsonPath, String paramName); static boolean isValidJsonPath(String jsonPath); static String validateDirPath(String path, String paramName); static boolean isValidDirPath(String path); static boolean isValidDirPath(String path, boolean mustEndWithSlash); static String validatePathPattern(String pathPattern, String paramName); static boolean isValidPathPattern(String pathPattern); static String validateProjectName(String projectName, String paramName); static boolean isValidProjectName(String projectName); static String validateRepositoryName(String repoName, String paramName); static boolean isValidRepositoryName(String repoName); static String validateEmailAddress(String emailAddr, String paramName); static boolean isValidEmailAddress(String emailAddr); static String toEmailAddress(String emailAddr, String paramName); static String emailToUsername(String emailAddr, String paramName); static List<String> stringToLines(String str); static String simpleTypeName(Object obj); static String simpleTypeName(Class<?> clazz); static String simpleTypeName(Class<?> clazz, boolean decapitalize); @SuppressWarnings("unchecked") static T unsafeCast(Object o); static Iterable<T> requireNonNullElements(Iterable<T> values, String name); static void deleteFileTree(File directory); }### Answer: @Test void testValidateFilePath() { assertFilePathValidationSuccess("/foo.txt"); assertFilePathValidationSuccess("/foo/bar.txt"); assertFilePathValidationSuccess("/foo.bar/baz.json"); assertFilePathValidationSuccess("/foo-bar/baz-json"); assertFilePathValidationFailure("foo"); assertFilePathValidationFailure("/"); assertFilePathValidationFailure("/foo/"); assertFilePathValidationFailure(" assertFilePathValidationFailure("/foo assertFilePathValidationFailure("/."); assertFilePathValidationFailure("/.."); assertFilePathValidationFailure("/.foo"); assertFilePathValidationFailure("/foo."); assertFilePathValidationFailure("/.foo."); assertFilePathValidationFailure("/\t"); assertFilePathValidationFailure("/80:20"); assertFilePathValidationFailure("/foo*.txt"); assertFilePathValidationFailure("/bar?.txt"); assertFilePathValidationFailure("/baz\|.txt"); assertFilePathValidationFailure("/\uAC00\uB098\uB2E4.json"); }
### Question: Util { public static String validateJsonFilePath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidJsonFilePath(path), "%s: %s (expected: %s)", paramName, path, JSON_FILE_PATH_PATTERN); return path; } private Util(); static String validateFileName(String name, String paramName); static boolean isValidFileName(String name); static String validateFilePath(String path, String paramName); static boolean isValidFilePath(String path); static String validateJsonFilePath(String path, String paramName); static boolean isValidJsonFilePath(String path); static String validateJsonPath(String jsonPath, String paramName); static boolean isValidJsonPath(String jsonPath); static String validateDirPath(String path, String paramName); static boolean isValidDirPath(String path); static boolean isValidDirPath(String path, boolean mustEndWithSlash); static String validatePathPattern(String pathPattern, String paramName); static boolean isValidPathPattern(String pathPattern); static String validateProjectName(String projectName, String paramName); static boolean isValidProjectName(String projectName); static String validateRepositoryName(String repoName, String paramName); static boolean isValidRepositoryName(String repoName); static String validateEmailAddress(String emailAddr, String paramName); static boolean isValidEmailAddress(String emailAddr); static String toEmailAddress(String emailAddr, String paramName); static String emailToUsername(String emailAddr, String paramName); static List<String> stringToLines(String str); static String simpleTypeName(Object obj); static String simpleTypeName(Class<?> clazz); static String simpleTypeName(Class<?> clazz, boolean decapitalize); @SuppressWarnings("unchecked") static T unsafeCast(Object o); static Iterable<T> requireNonNullElements(Iterable<T> values, String name); static void deleteFileTree(File directory); }### Answer: @Test void testValidateJsonFilePath() { assertJsonFilePathValidationSuccess("/foo.json"); assertJsonFilePathValidationSuccess("/foo/bar.json"); assertJsonFilePathValidationSuccess("/foo.bar/baz.json"); assertJsonFilePathValidationSuccess("/foo.JSON"); assertJsonFilePathValidationSuccess("/foo.Json"); assertJsonFilePathValidationSuccess("/foo.jsoN"); assertJsonFilePathValidationFailure("/foo.txt"); assertJsonFilePathValidationFailure("/foo/bar.txt"); assertJsonFilePathValidationFailure("/foo.bar/baz.json.txt"); assertJsonFilePathValidationFailure("/foo-bar/baz-json"); assertJsonFilePathValidationFailure("/"); assertJsonFilePathValidationFailure("/foo/"); assertJsonFilePathValidationFailure("/."); assertJsonFilePathValidationFailure("/.."); assertJsonFilePathValidationFailure("/.json"); assertJsonFilePathValidationFailure("/json."); assertJsonFilePathValidationFailure("/.json."); assertJsonFilePathValidationFailure("/\t"); assertJsonFilePathValidationFailure("/80:20"); assertJsonFilePathValidationFailure("/foo*.json"); assertJsonFilePathValidationFailure("/bar?.json"); assertJsonFilePathValidationFailure("/baz\|.json"); assertJsonFilePathValidationFailure("/\uAC00\uB098\uB2E4.json"); }
### Question: Util { public static String validateDirPath(String path, String paramName) { requireNonNull(path, paramName); checkArgument(isValidDirPath(path), "%s: %s (expected: %s)", paramName, path, DIR_PATH_PATTERN); return path; } private Util(); static String validateFileName(String name, String paramName); static boolean isValidFileName(String name); static String validateFilePath(String path, String paramName); static boolean isValidFilePath(String path); static String validateJsonFilePath(String path, String paramName); static boolean isValidJsonFilePath(String path); static String validateJsonPath(String jsonPath, String paramName); static boolean isValidJsonPath(String jsonPath); static String validateDirPath(String path, String paramName); static boolean isValidDirPath(String path); static boolean isValidDirPath(String path, boolean mustEndWithSlash); static String validatePathPattern(String pathPattern, String paramName); static boolean isValidPathPattern(String pathPattern); static String validateProjectName(String projectName, String paramName); static boolean isValidProjectName(String projectName); static String validateRepositoryName(String repoName, String paramName); static boolean isValidRepositoryName(String repoName); static String validateEmailAddress(String emailAddr, String paramName); static boolean isValidEmailAddress(String emailAddr); static String toEmailAddress(String emailAddr, String paramName); static String emailToUsername(String emailAddr, String paramName); static List<String> stringToLines(String str); static String simpleTypeName(Object obj); static String simpleTypeName(Class<?> clazz); static String simpleTypeName(Class<?> clazz, boolean decapitalize); @SuppressWarnings("unchecked") static T unsafeCast(Object o); static Iterable<T> requireNonNullElements(Iterable<T> values, String name); static void deleteFileTree(File directory); }### Answer: @Test void testValidateDirPath() { assertDirPathValidationSuccess("/"); assertDirPathValidationSuccess("/foo"); assertDirPathValidationSuccess("/foo/"); assertDirPathValidationSuccess("/foo/bar"); assertDirPathValidationSuccess("/foo/bar/"); assertDirPathValidationSuccess("/foo.bar/"); assertDirPathValidationSuccess("/foo-bar/"); assertDirPathValidationFailure("foo"); assertDirPathValidationFailure(" assertDirPathValidationFailure("/foo assertDirPathValidationFailure("/./"); assertDirPathValidationFailure("/../"); assertDirPathValidationFailure("/.foo/"); assertDirPathValidationFailure("/foo./"); assertDirPathValidationFailure("/.foo./"); assertDirPathValidationFailure("/\t/"); assertDirPathValidationFailure("/80:20/"); assertDirPathValidationFailure("/foo*/"); assertDirPathValidationFailure("/bar?/"); assertDirPathValidationFailure("/baz\|/"); assertDirPathValidationFailure("/\uAC00\uB098\uB2E4/"); }
### Question: WatchTimeout { public static long availableTimeout(long expectedTimeoutMillis) { return availableTimeout(expectedTimeoutMillis, 0); } private WatchTimeout(); static long availableTimeout(long expectedTimeoutMillis); static long availableTimeout(long expectedTimeoutMillis, long currentTimeoutMillis); static final long MAX_MILLIS; }### Answer: @Test void testMakeReasonable() { assertThat(availableTimeout(1_000, 0)).isEqualTo(1_000); assertThat(availableTimeout(1_000, 1_000)).isEqualTo(1_000); assertThat(availableTimeout(MAX_MILLIS, 1_000)).isEqualTo(MAX_MILLIS - 1_000); assertThat(availableTimeout(MAX_MILLIS + 1_000, 0)).isEqualTo(MAX_MILLIS); assertThat(availableTimeout(MAX_MILLIS - 1_000, 500)).isEqualTo(MAX_MILLIS - 1000); assertThatThrownBy(() -> availableTimeout(0, 1_000)) .isInstanceOf(IllegalArgumentException.class); assertThatThrownBy(() -> availableTimeout(-1, 1_000)) .isInstanceOf(IllegalArgumentException.class); assertThatThrownBy(() -> availableTimeout(1_000, -1)) .isInstanceOf(IllegalArgumentException.class); }
### Question: Entry implements ContentHolder<T> { public static Entry<String> ofText(Revision revision, String path, String content) { return new Entry<>(revision, path, EntryType.TEXT, content); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); static Entry<Void> ofDirectory(Revision revision, String path); static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content); static Entry<JsonNode> ofJson(Revision revision, String path, String content); static Entry<String> ofText(Revision revision, String path, String content); static Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content); Revision revision(); String path(); boolean hasContent(); void ifHasContent(Consumer<? super T> consumer); @Override EntryType type(); @Override T content(); @Override String contentAsText(); @Override String contentAsPrettyText(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test void ofText() throws Exception { final Entry<String> e = Entry.ofText(new Revision(1), "/a.txt", "foo"); assertThat(e.revision()).isEqualTo(new Revision(1)); assertThat(e.hasContent()).isTrue(); e.ifHasContent(content -> assertThat(content).isEqualTo("foo")); assertThat(e.content()).isEqualTo("foo"); assertThat(e.contentAsText()).isEqualTo("foo"); assertThat(e.contentAsPrettyText()).isEqualTo("foo"); assertThatThrownBy(e::contentAsJson).isInstanceOf(JsonParseException.class); assertThatThrownBy(() -> e.contentAsJson(JsonNode.class)).isInstanceOf(JsonParseException.class); assertThat(Entry.ofText(new Revision(1), "/a.txt", "null").contentAsJson()) .isEqualTo(Jackson.nullNode); assertThat(Entry.ofText(new Revision(1), "/a.txt", "null").contentAsJson(JsonNode.class)) .isEqualTo(Jackson.nullNode); final Entry<String> e2 = Entry.ofText(new Revision(1), "/a.txt", "foo"); assertThat(e).isEqualTo(e2); assertThat(e.hashCode()).isEqualTo(e2.hashCode()); assertThat(e).isNotEqualTo(Entry.ofText(new Revision(2), "/a.txt", "foo")); assertThat(e).isNotEqualTo(Entry.ofText(new Revision(1), "/b.txt", "foo")); assertThat(e).isNotEqualTo(Entry.ofText(new Revision(1), "/a.txt", "bar")); final Entry<JsonNode> e3 = Entry.ofJson(new Revision(1), "/a.json", "{ \"foo\": \"bar\" }"); assertThat(e).isNotEqualTo(e3); assertThat(e.hashCode()).isNotEqualTo(e3.hashCode()); final Entry<Void> e4 = Entry.ofDirectory(new Revision(1), "/foo"); assertThat(e).isNotEqualTo(e4); assertThat(e.hashCode()).isNotEqualTo(e4.hashCode()); }
### Question: JsonEndpointListDecoder implements EndpointListDecoder<JsonNode> { @Override public List<Endpoint> decode(JsonNode node) { final List<String> endpoints; try { endpoints = objectMapper.readValue(node.traverse(), new TypeReference<List<String>>() {}); } catch (IOException e) { throw new IllegalArgumentException("invalid format: " + node); } return convertToEndpointList(endpoints); } @Override List<Endpoint> decode(JsonNode node); }### Answer: @Test void decode() throws Exception { final EndpointListDecoder<JsonNode> decoder = EndpointListDecoder.JSON; final List<Endpoint> decoded = decoder.decode( objectMapper.readTree(objectMapper.writeValueAsString(HOST_AND_PORT_LIST))); assertThat(decoded).hasSize(4); assertThat(decoded).isEqualTo(ENDPOINT_LIST); }
### Question: TextEndpointListDecoder implements EndpointListDecoder<String> { @Override public List<Endpoint> decode(String object) { return convertToEndpointList(NEWLINE_SPLITTER.splitToList(object)); } @Override List<Endpoint> decode(String object); }### Answer: @Test void decode() { final EndpointListDecoder<String> decoder = EndpointListDecoder.TEXT; final List<Endpoint> decoded = decoder.decode(String.join("\n", HOST_AND_PORT_LIST)); assertThat(decoded).hasSize(4); assertThat(decoded).isEqualTo(ENDPOINT_LIST); }
### Question: ArmeriaCentralDogmaBuilder extends AbstractArmeriaCentralDogmaBuilder<ArmeriaCentralDogmaBuilder> { public CentralDogma build() throws UnknownHostException { final EndpointGroup endpointGroup = endpointGroup(); final String scheme = "none+" + (isUseTls() ? "https" : "http"); final ClientBuilder builder = newClientBuilder(scheme, endpointGroup, cb -> cb.decorator(DecodingClient.newDecorator()), "/"); final EventLoopGroup executor = clientFactory().eventLoopGroup(); final int maxRetriesOnReplicationLag = maxNumRetriesOnReplicationLag(); final CentralDogma dogma = new ArmeriaCentralDogma(executor, builder.build(WebClient.class), accessToken()); if (maxRetriesOnReplicationLag <= 0) { return dogma; } else { return new ReplicationLagTolerantCentralDogma( executor, dogma, maxRetriesOnReplicationLag, retryIntervalOnReplicationLagMillis(), () -> { final ClientRequestContext ctx = ClientRequestContext.currentOrNull(); return ctx != null ? ctx.remoteAddress() : null; }); } } CentralDogma build(); }### Answer: @Test void newClientBuilderCustomizationOrder() { final ClientFactory cf1 = mock(ClientFactory.class); final ClientFactory cf2 = mock(ClientFactory.class); final ClientFactory cf3 = mock(ClientFactory.class); final ArmeriaCentralDogmaBuilder b = new ArmeriaCentralDogmaBuilder(); final StringBuilder buf = new StringBuilder(); b.clientFactory(cf1); b.clientConfigurator(cb -> { buf.append('2'); cb.factory(cf2); }); final ClientBuilder cb = b.newClientBuilder("none+http", Endpoint.of("127.0.0.1"), cb2 -> { cb2.factory(cf3); buf.append('1'); }, "/"); assertThat(buf.toString()).isEqualTo("12"); cb.build(HttpClient.class); verify(cf1, times(1)).newClient(any()); verify(cf2, never()).newClient(any()); verify(cf3, never()).newClient(any()); }
### Question: LegacyCentralDogmaTimeoutScheduler extends SimpleDecoratingRpcClient { @Override public RpcResponse execute(ClientRequestContext ctx, RpcRequest req) throws Exception { final long responseTimeoutMillis = ctx.responseTimeoutMillis(); if (responseTimeoutMillis > 0) { final String method = req.method(); if ("watchFile".equals(method) \|\| "watchRepository".equals(method)) { final List<Object> params = req.params(); final long timeout = (Long) params.get(params.size() - 1); if (timeout > 0) { ctx.setResponseTimeoutMillis(TimeoutMode.EXTEND, WatchTimeout.availableTimeout(timeout, responseTimeoutMillis)); } } } return unwrap().execute(ctx, req); } LegacyCentralDogmaTimeoutScheduler(RpcClient delegate); @Override RpcResponse execute(ClientRequestContext ctx, RpcRequest req); }### Answer: @Test void execute() throws Exception { check("listProjects", 1000L, 1L, 1L); }
### Question: Entry implements ContentHolder<T> { public static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content) { return new Entry<>(revision, path, EntryType.JSON, content); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); static Entry<Void> ofDirectory(Revision revision, String path); static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content); static Entry<JsonNode> ofJson(Revision revision, String path, String content); static Entry<String> ofText(Revision revision, String path, String content); static Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content); Revision revision(); String path(); boolean hasContent(); void ifHasContent(Consumer<? super T> consumer); @Override EntryType type(); @Override T content(); @Override String contentAsText(); @Override String contentAsPrettyText(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test void ofJson() throws Exception { final Entry<JsonNode> e = Entry.ofJson(new Revision(1), "/a.json", "{ \"foo\": \"bar\" }"); assertThat(e.revision()).isEqualTo(new Revision(1)); assertThat(e.hasContent()).isTrue(); e.ifHasContent(content -> assertThatJson(content).isEqualTo("{ \"foo\": \"bar\" }")); assertThatJson(e.content()).isEqualTo("{ \"foo\": \"bar\" }"); assertThat(e.contentAsText()).isEqualTo("{\"foo\":\"bar\"}"); assertThat(e.contentAsPrettyText()).isEqualTo("{\n \"foo\": \"bar\"\n}"); assertThat(e.content()).isSameAs(e.contentAsJson()); assertThat(e.content()).isEqualTo(e.contentAsJson(JsonNode.class)); final Entry<JsonNode> e2 = Entry.ofJson(new Revision(1), "/a.json", "{ \"foo\": \"bar\" }"); assertThat(e).isEqualTo(e2); assertThat(e.hashCode()).isEqualTo(e2.hashCode()); assertThat(e).isNotEqualTo(Entry.ofJson(new Revision(2), "/a.json", "{ \"foo\": \"bar\" }")); assertThat(e).isNotEqualTo(Entry.ofJson(new Revision(1), "/b.json", "{ \"foo\": \"bar\" }")); assertThat(e).isNotEqualTo(Entry.ofJson(new Revision(1), "/a.json", "null")); final Entry<String> e3 = Entry.ofText(new Revision(1), "/a.json", "{\"foo\":\"bar\"}"); assertThat(e).isNotEqualTo(e3); assertThat(e.hashCode()).isNotEqualTo(e3.hashCode()); final Entry<Void> e4 = Entry.ofDirectory(new Revision(1), "/foo"); assertThat(e).isNotEqualTo(e4); assertThat(e.hashCode()).isNotEqualTo(e4.hashCode()); }
### Question: LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.createProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }### Answer: @Test void createProject() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(1); callback.onComplete(null); return null; }).when(iface).createProject(any(), any()); assertThat(client.createProject("project").get()).isNull(); verify(iface).createProject(eq("project"), any()); }
### Question: LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.removeProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }### Answer: @Test void removeProject() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(1); callback.onComplete(null); return null; }).when(iface).removeProject(any(), any()); assertThat(client.removeProject("project").get()).isNull(); verify(iface).removeProject(eq("project"), any()); }
### Question: LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.purgeProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }### Answer: @Test void purgeProject() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(1); callback.onComplete(null); return null; }).when(iface).purgeProject(any(), any()); assertThat(client.purgeProject("project").get()).isNull(); verify(iface).purgeProject(eq("project"), any()); }
### Question: LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.unremoveProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }### Answer: @Test void unremoveProject() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(1); callback.onComplete(null); return null; }).when(iface).unremoveProject(any(), any()); assertThat(client.unremoveProject("project").get()).isNull(); verify(iface).unremoveProject(eq("project"), any()); }
### Question: LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Set<String>> listProjects() { final CompletableFuture<List<Project>> future = run(client::listProjects); return future.thenApply(list -> convertToSet(list, Project::getName)); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }### Answer: @Test void listProjects() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<List<Project>> callback = invocation.getArgument(0); callback.onComplete(ImmutableList.of(new Project("project"))); return null; }).when(iface).listProjects(any()); assertThat(client.listProjects().get()).isEqualTo(ImmutableSet.of("project")); verify(iface).listProjects(any()); }
### Question: LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Set<String>> listRemovedProjects() { return run(client::listRemovedProjects); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }### Answer: @Test void listRemovedProjects() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Set<String>> callback = invocation.getArgument(0); callback.onComplete(ImmutableSet.of("project")); return null; }).when(iface).listRemovedProjects(any()); assertThat(client.listRemovedProjects().get()).isEqualTo(ImmutableSet.of("project")); verify(iface).listRemovedProjects(any()); }
### Question: LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.createRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }### Answer: @Test void createRepository() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(2); callback.onComplete(null); return null; }).when(iface).createRepository(anyString(), anyString(), any()); assertThat(client.createRepository("project", "repo").get()).isNull(); verify(iface).createRepository(eq("project"), eq("repo"), any()); }
### Question: LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.removeRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }### Answer: @Test void removeRepository() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(2); callback.onComplete(null); return null; }).when(iface).removeRepository(anyString(), anyString(), any()); assertThat(client.removeRepository("project", "repo").get()).isNull(); verify(iface).removeRepository(eq("project"), eq("repo"), any()); }
### Question: LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.purgeRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }### Answer: @Test void purgeRepository() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(2); callback.onComplete(null); return null; }).when(iface).purgeRepository(anyString(), anyString(), any()); assertThat(client.purgeRepository("project", "repo").get()).isNull(); verify(iface).purgeRepository(eq("project"), eq("repo"), any()); }
### Question: LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.unremoveRepository(projectName, repositoryName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projectName); @Override CompletableFuture<Void> removeProject(String projectName); @Override CompletableFuture<Void> purgeProject(String projectName); @Override CompletableFuture<Void> unremoveProject(String projectName); @Override CompletableFuture<Set<String>> listProjects(); @Override CompletableFuture<Set<String>> listRemovedProjects(); @Override CompletableFuture<Void> createRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> removeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> purgeRepository(String projectName, String repositoryName); @Override CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName); @Override CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName); @Override CompletableFuture<Set<String>> listRemovedRepositories(String projectName); @Override CompletableFuture<Revision> normalizeRevision(String projectName, String repositoryName, Revision revision); @Override CompletableFuture<Map<String, EntryType>> listFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<Entry<T>> getFile(String projectName, String repositoryName, Revision revision, Query<T> query); @Override CompletableFuture<Map<String, Entry<?>>> getFiles(String projectName, String repositoryName, Revision revision, String pathPattern); @Override CompletableFuture<MergedEntry<T>> mergeFiles(String projectName, String repositoryName, Revision revision, MergeQuery<T> mergeQuery); @Override CompletableFuture<List<Commit>> getHistory(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<Change<T>> getDiff(String projectName, String repositoryName, Revision from, Revision to, Query<T> query); @Override CompletableFuture<List<Change<?>>> getDiffs(String projectName, String repositoryName, Revision from, Revision to, String pathPattern); @Override CompletableFuture<List<Change<?>>> getPreviewDiffs(String projectName, String repositoryName, Revision baseRevision, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<PushResult> push(String projectName, String repositoryName, Revision baseRevision, Author author, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes); @Override CompletableFuture<Revision> watchRepository(String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis); @Override CompletableFuture<Entry<T>> watchFile(String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis); }### Answer: @Test void unremoveRepository() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<Void> callback = invocation.getArgument(2); callback.onComplete(null); return null; }).when(iface).unremoveRepository(anyString(), anyString(), any()); assertThat(client.unremoveRepository("project", "repo").get()).isNull(); verify(iface).unremoveRepository(eq("project"), eq("repo"), any()); }
### Question: Entry implements ContentHolder<T> { public static <T> Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content) { return new Entry<>(revision, path, type, content); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); static Entry<Void> ofDirectory(Revision revision, String path); static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content); static Entry<JsonNode> ofJson(Revision revision, String path, String content); static Entry<String> ofText(Revision revision, String path, String content); static Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content); Revision revision(); String path(); boolean hasContent(); void ifHasContent(Consumer<? super T> consumer); @Override EntryType type(); @Override T content(); @Override String contentAsText(); @Override String contentAsPrettyText(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test void of() { assertThatThrownBy(() -> Entry.of(null, "/1.txt", EntryType.TEXT, "1")) .isInstanceOf(NullPointerException.class); assertThatThrownBy(() -> Entry.of(new Revision(1), null, EntryType.TEXT, "1")) .isInstanceOf(NullPointerException.class); assertThatThrownBy(() -> Entry.of(new Revision(1), "/1.txt", null, "1")) .isInstanceOf(NullPointerException.class); assertThatThrownBy(() -> Entry.of(new Revision(1), "/1.txt", EntryType.TEXT, null)) .isInstanceOf(NullPointerException.class); assertThatThrownBy(() -> Entry.of(new Revision(1), "/1.txt", EntryType.TEXT, new Object())) .isInstanceOf(ClassCastException.class); Entry.of(new Revision(1), "/a", EntryType.DIRECTORY, null); assertThatThrownBy(() -> Entry.of(new Revision(1), "/a", EntryType.DIRECTORY, "foo")) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("expected: null"); }
### Question: Entry implements ContentHolder<T> { @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof Entry)) { return false; } @SuppressWarnings("unchecked") final Entry<T> that = (Entry<T>) o; return type == that.type && revision.equals(that.revision) && path.equals(that.path) && Objects.equals(content, that.content); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); static Entry<Void> ofDirectory(Revision revision, String path); static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content); static Entry<JsonNode> ofJson(Revision revision, String path, String content); static Entry<String> ofText(Revision revision, String path, String content); static Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content); Revision revision(); String path(); boolean hasContent(); void ifHasContent(Consumer<? super T> consumer); @Override EntryType type(); @Override T content(); @Override String contentAsText(); @Override String contentAsPrettyText(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test void testEquals() { final Entry<Void> e = Entry.ofDirectory(new Revision(1), "/foo"); assertThat(e).isNotEqualTo(null); assertThat(e).isNotEqualTo(new Object()); assertThat(e).isEqualTo(e); }
### Question: ZooKeeperReplicationConfig implements ReplicationConfig { @JsonProperty public int serverId() { return serverId; } ZooKeeperReplicationConfig(int serverId, Map<Integer, ZooKeeperAddress> servers); @VisibleForTesting ZooKeeperReplicationConfig( int serverId, Map<Integer, ZooKeeperAddress> servers, String secret, Map<String, String> additionalProperties, int timeoutMillis, int numWorkers, int maxLogCount, long minLogAgeMillis); @JsonCreator ZooKeeperReplicationConfig(@JsonProperty("serverId") @Nullable Integer serverId, @JsonProperty(value = "servers", required = true) @JsonDeserialize(keyAs = Integer.class, contentAs = ZooKeeperAddress.class) Map<Integer, ZooKeeperAddress> servers, @JsonProperty("secret") @Nullable String secret, @JsonProperty("additionalProperties") @JsonDeserialize(keyAs = String.class, contentAs = String.class) @Nullable Map<String, String> additionalProperties, @JsonProperty("timeoutMillis") @Nullable Integer timeoutMillis, @JsonProperty("numWorkers") @Nullable Integer numWorkers, @JsonProperty("maxLogCount") @Nullable Integer maxLogCount, @JsonProperty("minLogAgeMillis") @Nullable Long minLogAgeMillis); @Override ReplicationMethod method(); @JsonProperty int serverId(); ZooKeeperAddress serverAddress(); @JsonProperty Map<Integer, ZooKeeperAddress> servers(); String secret(); @JsonProperty Map<String, String> additionalProperties(); @JsonProperty int timeoutMillis(); @JsonProperty int numWorkers(); @JsonProperty int maxLogCount(); @JsonProperty long minLogAgeMillis(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test void autoDetection() throws Exception { final ZooKeeperReplicationConfig cfg = Jackson.readValue( '{' + " \"method\": \"ZOOKEEPER\"," + " \"servers\": {" + " \"1\": {" + " \"host\": \"127.0.0.1\"," + " \"quorumPort\": 100," + " \"electionPort\": 101" + " }," + " \"2\": {" + " \"host\": \"255.255.255.255\"," + " \"quorumPort\": 200," + " \"electionPort\": 201" + " }" + " }" + '}', ZooKeeperReplicationConfig.class); assertThat(cfg.serverId()).isEqualTo(1); }
### Question: Entry implements ContentHolder<T> { @Override public String toString() { return MoreObjects.toStringHelper(this).omitNullValues() .add("revision", revision.text()) .add("path", path) .add("type", type) .add("content", hasContent() ? contentAsText() : null) .toString(); } private Entry(Revision revision, String path, EntryType type, @Nullable T content); static Entry<Void> ofDirectory(Revision revision, String path); static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content); static Entry<JsonNode> ofJson(Revision revision, String path, String content); static Entry<String> ofText(Revision revision, String path, String content); static Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content); Revision revision(); String path(); boolean hasContent(); void ifHasContent(Consumer<? super T> consumer); @Override EntryType type(); @Override T content(); @Override String contentAsText(); @Override String contentAsPrettyText(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test void testToString() { assertThat(Entry.ofText(new Revision(1), "/a.txt", "a").toString()).isNotEmpty(); }
### Question: CreateProjectCommand extends RootCommand<Void> { @JsonProperty public String projectName() { return projectName; } @JsonCreator CreateProjectCommand(@JsonProperty("timestamp") @Nullable Long timestamp, @JsonProperty("author") @Nullable Author author, @JsonProperty("projectName") String projectName); @JsonProperty String projectName(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test void backwardCompatibility() throws Exception { final CreateProjectCommand c = (CreateProjectCommand) Jackson.readValue( '{' + " \"type\": \"CREATE_PROJECT\"," + " \"projectName\": \"foo\"" + '}', Command.class); assertThat(c.author()).isEqualTo(Author.SYSTEM); assertThat(c.timestamp()).isNotZero(); assertThat(c.projectName()).isEqualTo("foo"); }
### Question: PurgeProjectCommand extends RootCommand<Void> { @JsonProperty public String projectName() { return projectName; } @JsonCreator PurgeProjectCommand(@JsonProperty("timestamp") @Nullable Long timestamp, @JsonProperty("author") @Nullable Author author, @JsonProperty("projectName") String projectName); @JsonProperty String projectName(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test void backwardCompatibility() throws Exception { final PurgeProjectCommand c = (PurgeProjectCommand) Jackson.readValue( '{' + " \"type\": \"PURGE_PROJECT\"," + " \"projectName\": \"foo\"" + '}', Command.class); assertThat(c.author()).isEqualTo(Author.SYSTEM); assertThat(c.timestamp()).isNotZero(); assertThat(c.projectName()).isEqualTo("foo"); }
### Question: RemoveProjectCommand extends RootCommand<Void> { @JsonProperty public String projectName() { return projectName; } @JsonCreator RemoveProjectCommand(@JsonProperty("timestamp") @Nullable Long timestamp, @JsonProperty("author") @Nullable Author author, @JsonProperty("projectName") String projectName); @JsonProperty String projectName(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test void backwardCompatibility() throws Exception { final RemoveProjectCommand c = (RemoveProjectCommand) Jackson.readValue( '{' + " \"type\": \"REMOVE_PROJECT\"," + " \"projectName\": \"foo\"" + '}', Command.class); assertThat(c.author()).isEqualTo(Author.SYSTEM); assertThat(c.timestamp()).isNotZero(); assertThat(c.projectName()).isEqualTo("foo"); }
### Question: PurgeRepositoryCommand extends ProjectCommand<Void> { @JsonProperty public String repositoryName() { return repositoryName; } @JsonCreator PurgeRepositoryCommand(@JsonProperty("timestamp") @Nullable Long timestamp, @JsonProperty("author") @Nullable Author author, @JsonProperty("projectName") String projectName, @JsonProperty("repositoryName") String repositoryName); @JsonProperty String repositoryName(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test void backwardCompatibility() throws Exception { final PurgeRepositoryCommand c = (PurgeRepositoryCommand) Jackson.readValue( '{' + " \"type\": \"PURGE_REPOSITORY\"," + " \"projectName\": \"foo\"," + " \"repositoryName\": \"bar\"" + '}', Command.class); assertThat(c.author()).isEqualTo(Author.SYSTEM); assertThat(c.timestamp()).isNotZero(); assertThat(c.projectName()).isEqualTo("foo"); assertThat(c.repositoryName()).isEqualTo("bar"); }
### Question: RemoveRepositoryCommand extends ProjectCommand<Void> { @JsonProperty public String repositoryName() { return repositoryName; } @JsonCreator RemoveRepositoryCommand(@JsonProperty("timestamp") @Nullable Long timestamp, @JsonProperty("author") @Nullable Author author, @JsonProperty("projectName") String projectName, @JsonProperty("repositoryName") String repositoryName); @JsonProperty String repositoryName(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test void backwardCompatibility() throws Exception { final RemoveRepositoryCommand c = (RemoveRepositoryCommand) Jackson.readValue( '{' + " \"type\": \"REMOVE_REPOSITORY\"," + " \"projectName\": \"foo\"," + " \"repositoryName\": \"bar\"" + '}', Command.class); assertThat(c.author()).isEqualTo(Author.SYSTEM); assertThat(c.timestamp()).isNotZero(); assertThat(c.projectName()).isEqualTo("foo"); assertThat(c.repositoryName()).isEqualTo("bar"); }
### Question: CreateRepositoryCommand extends ProjectCommand<Void> { @JsonProperty public String repositoryName() { return repositoryName; } @JsonCreator CreateRepositoryCommand(@JsonProperty("timestamp") @Nullable Long timestamp, @JsonProperty("author") @Nullable Author author, @JsonProperty("projectName") String projectName, @JsonProperty("repositoryName") String repositoryName); @JsonProperty String repositoryName(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test void backwardCompatibility() throws Exception { final CreateRepositoryCommand c = (CreateRepositoryCommand) Jackson.readValue( '{' + " \"type\": \"CREATE_REPOSITORY\"," + " \"projectName\": \"foo\"," + " \"repositoryName\": \"bar\"" + '}', Command.class); assertThat(c.author()).isEqualTo(Author.SYSTEM); assertThat(c.timestamp()).isNotZero(); assertThat(c.projectName()).isEqualTo("foo"); assertThat(c.repositoryName()).isEqualTo("bar"); }
### Question: RevisionRange { public RevisionRange(int from, int to) { this(new Revision(from), new Revision(to)); } RevisionRange(int from, int to); RevisionRange(Revision from, Revision to); Revision from(); Revision to(); RevisionRange toAscending(); RevisionRange toDescending(); boolean isAscending(); boolean isRelative(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test void revisionRange() { RevisionRange range = new RevisionRange(2, 4); assertThat(range.isAscending()).isTrue(); assertThat(range.isRelative()).isFalse(); assertThat(range.toAscending()).isSameAs(range); assertThat(range.toDescending()).isEqualTo(new RevisionRange(4, 2)); final Revision revisionTen = new Revision(10); range = new RevisionRange(revisionTen, INIT); assertThat(range.isAscending()).isFalse(); assertThat(range.isRelative()).isFalse(); assertThat(range.toAscending()).isEqualTo(new RevisionRange(INIT, revisionTen)); assertThat(range.toDescending()).isSameAs(range); range = new RevisionRange(revisionTen, revisionTen); assertThat(range.isAscending()).isFalse(); assertThat(range.isRelative()).isFalse(); assertThat(range.toAscending()).isSameAs(range); assertThat(range.toDescending()).isSameAs(range); final Revision revisionNegativeThree = new Revision(-3); final Revision revisionNegativeTen = new Revision(-10); range = new RevisionRange(revisionNegativeTen, revisionNegativeThree); assertThat(range.isAscending()).isTrue(); assertThat(range.isRelative()).isTrue(); assertThat(range.toAscending()).isSameAs(range); assertThat(range.toDescending()).isEqualTo( new RevisionRange(revisionNegativeThree, revisionNegativeTen)); final RevisionRange relativeRange = new RevisionRange(INIT, HEAD); assertThat(relativeRange.isRelative()).isTrue(); assertThat(relativeRange.from()).isSameAs(INIT); assertThat(relativeRange.to()).isSameAs(HEAD); assertThatThrownBy(relativeRange::isAscending) .isExactlyInstanceOf(IllegalStateException.class); assertThatThrownBy(relativeRange::toAscending) .isExactlyInstanceOf(IllegalStateException.class); assertThatThrownBy(relativeRange::toDescending) .isExactlyInstanceOf(IllegalStateException.class); }
### Question: UnremoveRepositoryCommand extends ProjectCommand<Void> { @JsonProperty public String repositoryName() { return repositoryName; } @JsonCreator UnremoveRepositoryCommand(@JsonProperty("timestamp") @Nullable Long timestamp, @JsonProperty("author") @Nullable Author author, @JsonProperty("projectName") String projectName, @JsonProperty("repositoryName") String repositoryName); @JsonProperty String repositoryName(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test void backwardCompatibility() throws Exception { final UnremoveRepositoryCommand c = (UnremoveRepositoryCommand) Jackson.readValue( '{' + " \"type\": \"UNREMOVE_REPOSITORY\"," + " \"projectName\": \"foo\"," + " \"repositoryName\": \"bar\"" + '}', Command.class); assertThat(c.author()).isEqualTo(Author.SYSTEM); assertThat(c.timestamp()).isNotZero(); assertThat(c.projectName()).isEqualTo("foo"); assertThat(c.repositoryName()).isEqualTo("bar"); }

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.