target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@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(ExamplePa... | @Override public void processQueries(Collection<? extends Query<I, D>> queries) { MQUtil.answerQueries(this, queries); } | SimulatorOracle implements SingleQueryOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { MQUtil.answerQueries(this, queries); } } | SimulatorOracle implements SingleQueryOracle<I, D> { @Override public void processQueries(Collection<? extends Query<I, D>> queries) { MQUtil.answerQueries(this, queries); } SimulatorOracle(SuffixOutput<I, D> automaton); } | 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<?... | 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<?... |
@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... | @Override public void reset() { super.reset(); this.fetchRequired = true; } | StateLocalInputSULSymbolQueryOracle extends SULSymbolQueryOracle<I, O> implements SymbolQueryOracle<I, O> { @Override public void reset() { super.reset(); this.fetchRequired = true; } } | 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); } | 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(); } | 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(); } |
@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, exampl... | @Override public void reset() { super.reset(); this.fetchRequired = true; } | StateLocalInputSULSymbolQueryOracle extends SULSymbolQueryOracle<I, O> implements SymbolQueryOracle<I, O> { @Override public void reset() { super.reset(); this.fetchRequired = true; } } | 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); } | 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(); } | 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(); } |
@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_... | @Override public boolean canFork() { return mapper1.canFork() && mapper2.canFork(); } | 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 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(); } SULMapperC... | 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(); } SULMapperC... | 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(); } SULMapperC... |
@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)); } | @Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); } | 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 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<... | 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<... | 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<... |
@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 Nul... | @Override public void processQueries(Collection<? extends OmegaQuery<I, D>> omegaQueries) { processBatch(omegaQueries); } | 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 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<? ext... | 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<? ext... | 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<? ext... |
@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<I, D>> omegaQueries) { processBatch(omegaQueries); } | 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 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<? ext... | 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<? ext... | 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<? ext... |
@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)); } | @Override public boolean isSameState(Word<I> w1, S s1, Word<I> w2, S s2) { return getProcessor().isSameState(w1, s1, w2, s2); } | 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 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... | 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... | 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... |
@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 Nul... | @Override public void processQueries(Collection<? extends Query<I, D>> queries) { processBatch(queries); } | 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 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,
... | 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,
... | 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,
... |
@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<I, D>> queries) { processBatch(queries); } | 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 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,
... | 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,
... | 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,
... |
@Test(dependsOnMethods = "testInitialState") public void testFirstQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2); oracle.processQueries(queries); verifyCounts(2, 0, 0, 0); } | @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 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 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 na... | 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 na... | 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 na... |
@Test(dependsOnMethods = "testFirstQueryBatch") public void testEmptyQueryBatch() { Collection<Query<Integer, Word<Character>>> noQueries = Collections.emptySet(); oracle.processQueries(noQueries); verifyCounts(2, 0, 0, 0); } | @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 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 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 na... | 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 na... | 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 na... |
@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); } | @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 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 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 na... | 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 na... | 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 na... |
@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_deta... | @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } | HistogramOracle implements StatisticOracle<I, D> { @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } } | HistogramOracle implements StatisticOracle<I, D> { @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } HistogramOracle(MembershipOracle<I, D> next, String name); } | 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 getStatisti... | 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 getStatisti... |
@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"); } | @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 ... | 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<? ... | 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<? ... | 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<? ... | 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<? ... |
@Test public void testGetName() { Assert.assertEquals(oracle.getStatisticalData().getName(), COUNTER_NAME); } | @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } | HistogramOracle implements StatisticOracle<I, D> { @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } } | HistogramOracle implements StatisticOracle<I, D> { @Override public final HistogramDataSet getStatisticalData() { return this.dataSet; } HistogramOracle(MembershipOracle<I, D> next, String name); } | 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 getStatisti... | 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 getStatisti... |
@Test public void testInitialState() { Assert.assertEquals(oracle.getCount(), 0L); } | public long getCount() { return counter.getCount(); } | CounterOracle implements StatisticOracle<I, D> { public long getCount() { return counter.getCount(); } } | CounterOracle implements StatisticOracle<I, D> { public long getCount() { return counter.getCount(); } CounterOracle(MembershipOracle<I, D> nextOracle, String name); } | 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(); @... | 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(); @... |
@Test public void testGetName() { Assert.assertEquals(oracle.getCounter().getName(), COUNTER_NAME); } | public Counter getCounter() { return this.counter; } | CounterOracle implements StatisticOracle<I, D> { public Counter getCounter() { return this.counter; } } | CounterOracle implements StatisticOracle<I, D> { public Counter getCounter() { return this.counter; } CounterOracle(MembershipOracle<I, D> nextOracle, String name); } | 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(); @O... | 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(); @O... |
@Test(dependsOnMethods = "testInitialState") public void testFirstQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2); oracle.processQueries(queries); verifyCounts(2, 0); } | @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 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 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(Me... | 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(Me... | 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(Me... |
@Test(dependsOnMethods = "testFirstQueryBatch") public void testEmptyQueryBatch() { Collection<Query<Integer, Word<Character>>> noQueries = Collections.emptySet(); oracle.processQueries(noQueries); verifyCounts(2, 0); } | @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 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 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(Me... | 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(Me... | 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(Me... |
@Test(dependsOnMethods = "testEmptyQueryBatch") public void testSecondQueryBatch() { Collection<Query<Integer, Word<Character>>> queries = TestQueries.createNoopQueries(2, 5, TestQueries.INPUTS); oracle.processQueries(queries); verifyCounts(4, 10); } | @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 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 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(Me... | 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(Me... | 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(Me... |
@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(); MealyS... | @Override public CompactMealy<I, O> getHypothesisModel() { checkInternalState(); return hypothesis; } | MealyDHC implements MealyLearner<I, O>,
AccessSequenceTransformer<I>,
GlobalSuffixLearnerMealy<I, O>,
SupportsGrowingAlphabet<I>,
Resumable<MealyDHCState<I, O>> { @... | MealyDHC implements MealyLearner<I, O>,
AccessSequenceTransformer<I>,
GlobalSuffixLearnerMealy<I, O>,
SupportsGrowingAlphabet<I>,
Resumable<MealyDHCState<I, O>> { @... | MealyDHC implements MealyLearner<I, O>,
AccessSequenceTransformer<I>,
GlobalSuffixLearnerMealy<I, O>,
SupportsGrowingAlphabet<I>,
Resumable<MealyDHCState<I, O>> { @... | MealyDHC implements MealyLearner<I, O>,
AccessSequenceTransformer<I>,
GlobalSuffixLearnerMealy<I, O>,
SupportsGrowingAlphabet<I>,
Resumable<MealyDHCState<I, O>> { @... |
@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(s... | @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 (... | 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 A... | 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 A... | 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 A... | 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 A... |
@Test public void testFindCounterExample() { final DefaultQuery<Character, D> cex = bfeo.findCounterExample(automaton, ALPHABET); Assert.assertEquals(cex, query); } | @Override public @Nullable DefaultQuery<I, D> findCounterExample(A hypothesis, Collection<? extends I> inputs) { return super.findCounterExample(hypothesis, inputs); } | 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); } } | 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<... | 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<... | 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<... |
@Test public void testIsCounterExample() { bfeo.isCounterExample(automaton, query.getInput(), query.getOutput()); } | @Override public boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, @Nullable D output) { return EmptinessOracle.super.isCounterExample(hypothesis, inputs, output); } | 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); } } | 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(... | 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(... | 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(... |
@Test public void testGetPropertyOracles() { Assert.assertEquals(oracle.getPropertyOracles().size(), 2); } | @Override public List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles() { return propertyOracles; } | DisproveFirstOracle implements BlackBoxOracle<A, I, D> { @Override public List<PropertyOracle<I, ? super A, ?, D>> getPropertyOracles() { return propertyOracles; } } | 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, ... | 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, ... | 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, ... |
@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()).do... | @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.isDisprov... | 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, ?... | 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, ?... | 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, ?... | 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, ?... |
@Test public void testIsCounterExample() { Assert.assertTrue(bfio.isCounterExample(automaton, query.getInput(), query.getOutput())); } | @Override public boolean isCounterExample(A hypothesis, Iterable<? extends I> inputs, D output) { return InclusionOracle.super.isCounterExample(hypothesis, inputs, output); } | 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 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... | 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... | 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... |
@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).isInstanc... | public static Entry<Void> ofDirectory(Revision revision, String path) { return new Entry<>(revision, path, EntryType.DIRECTORY, null); } | Entry implements ContentHolder<T> { public static Entry<Void> ofDirectory(Revision revision, String path) { return new Entry<>(revision, path, EntryType.DIRECTORY, null); } } | 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); } | 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)... | 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)... |
@Test void testEmptyMirrors() { assertThat(metaRepo.mirrors()).isEmpty(); metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert("/credentials.json", "[]")); assertThat(metaRepo.mirrors()).isEmpty(); metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert("/mirrors.json", "[]")); asse... | @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } retu... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... |
@Test void testInvalidMirrors() { metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert(PATH_MIRRORS, "{}")).join(); assertThatThrownBy(() -> metaRepo.mirrors()).isInstanceOf(RepositoryMetadataException.class); metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert(PATH_MIRRORS, "\"... | @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } retu... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... |
@Test void testSingleTypeMirror() { metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert( PATH_MIRRORS, "[{" + " \"enabled\": true," + " \"type\": \"single\"," + " \"direction\": \"LOCAL_TO_REMOTE\"," + " \"localRepo\": \"foo\"," + " \"localPath\": \"/mirrors/foo\"," + " \"remoteUri\": \"git+ssh: "}... | @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } retu... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... |
@Test void testMultipleTypeMirror() { metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert( PATH_MIRRORS, "[{" + " \"enabled\": true," + " \"type\": \"multiple\"," + " \"defaultDirection\": \"LOCAL_TO_REMOTE\"," + " \"defaultLocalPath\": \"/source\"," + " \"includes\": [{" + " \"pattern\": \"^([^.]+... | @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } retu... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... |
@Test void testMultipleTypeMirrorWithCredentialId() { metaRepo.commit(Revision.HEAD, 0, Author.SYSTEM, "", Change.ofJsonUpsert( PATH_MIRRORS, "[{" + " \"type\": \"multiple\"," + " \"defaultDirection\": \"REMOTE_TO_LOCAL\"," + " \"includes\": [{" + " \"pattern\": \"^(foo|bar)$\"," + " \"replacement\": \"git+ssh: " \"cre... | @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirrors = loadMirrors(headRev); mirrorRev = headRev; mirrorRepos = repos; } retu... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... | DefaultMetaRepository extends RepositoryWrapper implements MetaRepository { @Override public Set<Mirror> mirrors() { mirrorLock.lock(); try { final int headRev = normalizeNow(Revision.HEAD).major(); final Set<String> repos = parent().repos().list().keySet(); if (headRev > mirrorRev || !mirrorRepos.equals(repos)) { mirr... |
@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).no... | @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 ... | 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 normalized... | 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 normalized... | 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 normalized... | 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 normalized... |
@Test void history() { final Repository repo = setMockNames(newCachingRepo()); final List<Commit> commits = ImmutableList.of( new Commit(new Revision(3), SYSTEM, "third", "", Markup.MARKDOWN), new Commit(new Revision(3), SYSTEM, "second", "", Markup.MARKDOWN), new Commit(new Revision(3), SYSTEM, "first", "", Markup.MAR... | @Override public CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits) { requireNonNull(from, "from"); requireNonNull(to, "to"); requireNonNull(pathPattern, "pathPattern"); if (maxCommits <= 0) { throw new IllegalArgumentException("maxCommits: " + maxCommits + " (expect... | CachingRepository implements Repository { @Override public CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits) { requireNonNull(from, "from"); requireNonNull(to, "to"); requireNonNull(pathPattern, "pathPattern"); if (maxCommits <= 0) { throw new IllegalArgumentExcepti... | CachingRepository implements Repository { @Override public CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits) { requireNonNull(from, "from"); requireNonNull(to, "to"); requireNonNull(pathPattern, "pathPattern"); if (maxCommits <= 0) { throw new IllegalArgumentExcepti... | CachingRepository implements Repository { @Override public CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits) { requireNonNull(from, "from"); requireNonNull(to, "to"); requireNonNull(pathPattern, "pathPattern"); if (maxCommits <= 0) { throw new IllegalArgumentExcepti... | CachingRepository implements Repository { @Override public CompletableFuture<List<Commit>> history(Revision from, Revision to, String pathPattern, int maxCommits) { requireNonNull(from, "from"); requireNonNull(to, "to"); requireNonNull(pathPattern, "pathPattern"); if (maxCommits <= 0) { throw new IllegalArgumentExcepti... |
@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}"); assert... | @Override public Revision normalizeNow(Revision revision) { return repo.normalizeNow(revision); } | CachingRepository implements Repository { @Override public Revision normalizeNow(Revision revision) { return repo.normalizeNow(revision); } } | CachingRepository implements Repository { @Override public Revision normalizeNow(Revision revision) { return repo.normalizeNow(revision); } CachingRepository(Repository repo, RepositoryCache cache); } | 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 ... | 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 ... |
@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/"); } | 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; } w... | 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 >>>= ... | 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 >>>= ... | 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 >>>= ... | 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 >>>= ... |
@Test void testByteHexDirNameException() { assertThatIllegalArgumentException() .isThrownBy(() -> TagUtil.byteHexDirName(0)); assertThatIllegalArgumentException() .isThrownBy(() -> TagUtil.byteHexDirName(-1)); } | 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; } w... | 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 >>>= ... | 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 >>>= ... | 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 >>>= ... | 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 >>>= ... |
@Test void cannotPatchNull() { final JsonPatch patch = new JsonPatch(ImmutableList.of(op1, op2)); assertThatNullPointerException() .isThrownBy(() -> patch.apply(null)); } | public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } | 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; } } | 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); } | 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); stati... | 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); stati... |
@Test void testRemoval() { assertThatThrownBy(() -> repo .commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofRemoval(jsonPaths[0])).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); Revision revision = repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]).join... | @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... |
@Test void testRename() { repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]).join(); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofRename(jsonPaths[0], jsonPaths[1])).join(); assertThat(repo.exists(HEAD, jsonPaths[0]).join()).isFalse(); assertThat(repo.exists(HEAD, jsonPaths[1]).join()).isTrue(); ... | @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... |
@Test void testRenameFailure() { assertThatThrownBy(() -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0], jsonUpserts[1], Change.ofRename(jsonPaths[0], jsonPaths[1])).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); repo.commit(HEAD, 0L, Author.UNKNOWN,... | @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... |
@Test void testLateCommit() { final Revision rev = repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]).join(); assertThatThrownBy(() -> repo .commit(new Revision(rev.major() - 1), 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[1]).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictE... | @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... |
@Test void testEmptyCommit() { assertThatThrownBy( () -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Collections.emptyList()).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(RedundantChangeException.class); } | @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... |
@Test void testEmptyCommitWithRedundantRenames() { repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]).join(); assertThatThrownBy(() -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofRename(jsonPaths[0], jsonPaths[1]), Change.ofRename(jsonPaths[1], jsonPaths[0])).join()) .isInstanceOf(CompletionExce... | @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... |
@Test void testEmptyCommitWithRedundantUpsert() { assertThatThrownBy( () -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Collections.emptyList()).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(RedundantChangeException.class); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]).join();... | @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... |
@Test void testEmptyCommitWithRedundantUpsert2() { final Change<JsonNode> change1 = Change.ofJsonUpsert("/redundant_upsert_2.json", "{ \"foo\": 0, \"bar\": 1 }"); final Change<String> change2 = Change.ofTextUpsert("/redundant_upsert_2.txt", "foo"); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, change1).join(); repo.co... | @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... |
@Test void testTextSanitization() { final Change<String> dosText = Change.ofTextUpsert("/text_sanitization_dos.txt", "foo\r\nbar\r\n"); repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, dosText).join(); assertThat(repo.get(HEAD, dosText.path()).join().contentAsText()).isEqualTo("foo\nbar\n"); assertThatThrownBy(() -> repo... | @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... |
@Test void testRenameWithConflict() { repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]).join(); assertThatThrownBy(() -> repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofRename(jsonPaths[0], jsonPaths[0])).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.c... | @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... |
@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(JsonN... | public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } | 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; } } | 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); } | 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); stati... | 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); stati... |
@Test void testMultipleChangesWithConflict() { assertThatThrownBy(() -> repo .commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0], jsonPatches[2]).join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(ChangeConflictException.class); } | @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... |
@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(C... | @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(baseRevisi... | 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);... | 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);... | 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);... | 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);... |
@Test void testFindNone() { assertThat(repo.find(HEAD, "/non-existent").join()).isEmpty(); assertThat(repo.find(HEAD, "non-existent").join()).isEmpty(); } | @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 blocking... | 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, ... | 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, ... | 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, ... | 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, ... |
@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); } | @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 blocking... | 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, ... | 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, ... | 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, ... | 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, ... |
@Test void testJsonPathQuery() { repo.commit(HEAD, 0L, Author.UNKNOWN, SUMMARY, Change.ofJsonUpsert("/instances.json", '[' + " {" + " \"name\": \"a\"," + " \"groups\": [{" + " \"type\": \"phase\"," + " \"name\": \"alpha\"" + " }, {" + " \"type\": \"not_phase\"," + " \"name\": \"beta\"" + " }]" + " }, {" + " \"name\": \... | @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { failFastIfTimedOut(this, logger, ctx, "... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... | GitRepository implements Repository { @Override public CompletableFuture<Revision> commit( Revision baseRevision, long commitTimeMillis, Author author, String summary, String detail, Markup markup, Iterable<Change<?>> changes) { final ServiceRequestContext ctx = context(); return CompletableFuture.supplyAsync(() -> { f... |
@Test void testWatch() throws Exception { final Revision rev1 = repo.normalizeNow(HEAD); final Revision rev2 = rev1.forward(1); final CompletableFuture<Revision> f = repo.watch(rev1, Repository.ALL_PATH); assertThat(f).isNotDone(); repo.commit(rev1, 0L, Author.UNKNOWN, SUMMARY, jsonUpserts[0]); assertThat(f.get(3, Time... | @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision = normalizeNow(lastKnownRevision); fi... | GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision... | GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision... | GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision... | GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision... |
@Test void testWatchWithQueryCancellation() throws Exception { final AtomicInteger numSubtasks = new AtomicInteger(); final CountDownLatch subtaskCancelled = new CountDownLatch(1); watchConsumer = f -> { numSubtasks.getAndIncrement(); f.exceptionally(cause -> { if (cause instanceof CancellationException) { subtaskCance... | @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision = normalizeNow(lastKnownRevision); fi... | GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision... | GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision... | GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision... | GitRepository implements Repository { @Override public CompletableFuture<Revision> watch(Revision lastKnownRevision, String pathPattern) { requireNonNull(lastKnownRevision, "lastKnownRevision"); requireNonNull(pathPattern, "pathPattern"); final ServiceRequestContext ctx = context(); final Revision normLastKnownRevision... |
@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).... | @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... | 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 In... | 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 In... | 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 In... | 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 In... |
@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 = newRequestWithoutTo... | @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... | 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 In... | 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 In... | 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 In... | 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 In... |
@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)); } | @Nullable public byte[] passphrase() { if (passphrase == null) { return null; } else { return passphrase.clone(); } } | PublicKeyMirrorCredential extends AbstractMirrorCredential { @Nullable public byte[] passphrase() { if (passphrase == null) { return null; } else { return passphrase.clone(); } } } | PublicKeyMirrorCredential extends AbstractMirrorCredential { @Nullable public byte[] passphrase() { if (passphrase == null) { return null; } else { return passphrase.clone(); } } @JsonCreator PublicKeyMirrorCredential(@JsonProperty("id") @Nullable String id,
@JsonProperty("hostname... | PublicKeyMirrorCredential extends AbstractMirrorCredential { @Nullable public byte[] passphrase() { if (passphrase == null) { return null; } else { return passphrase.clone(); } } @JsonCreator PublicKeyMirrorCredential(@JsonProperty("id") @Nullable String id,
@JsonProperty("hostname... | PublicKeyMirrorCredential extends AbstractMirrorCredential { @Nullable public byte[] passphrase() { if (passphrase == null) { return null; } else { return passphrase.clone(); } } @JsonCreator PublicKeyMirrorCredential(@JsonProperty("id") @Nullable String id,
@JsonProperty("hostname... |
@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(JsonPatc... | public JsonNode apply(final JsonNode node) { requireNonNull(node, "node"); JsonNode ret = node.deepCopy(); for (final JsonPatchOperation operation : operations) { ret = operation.apply(ret); } return ret; } | 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; } } | 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); } | 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); stati... | 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); stati... |
@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 ExpiredSessionDeletingSessionMana... | @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 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 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 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 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... |
@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 ExpiredSessionDeletin... | @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 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 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 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 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... |
@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... | @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.newRespons... | 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 ... | 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 ... | 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 ... | 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 ... |
@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.contentUtf... | @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.newRespons... | 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 ... | 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 ... | 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 ... | 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 ... |
@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( '{'... | @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.newRespons... | 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 ... | 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 ... | 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 ... | 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 ... |
@Test void maxRemovedRepositoryAgeMillis() throws Exception { final CentralDogmaConfig cfg = Jackson.readValue("{\n" + " \"dataDir\": \"./data\",\n" + " \"ports\": [\n" + " {\n" + " \"localAddress\": {\n" + " \"host\": \"*\",\n" + " \"port\": 36462\n" + " },\n" + " \"protocols\": [\n" + " \"https\",\n" + " \"http\",\n"... | @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } | CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } } | CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } CentralDogmaConfig(
@JsonProperty(value = "dataDir", required = true) File dataDir,
@JsonProperty(value = "ports", required = true)
@JsonDeserialize(contentUsing =... | CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } CentralDogmaConfig(
@JsonProperty(value = "dataDir", required = true) File dataDir,
@JsonProperty(value = "ports", required = true)
@JsonDeserialize(contentUsing =... | CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } CentralDogmaConfig(
@JsonProperty(value = "dataDir", required = true) File dataDir,
@JsonProperty(value = "ports", required = true)
@JsonDeserialize(contentUsing =... |
@Test void maxRemovedRepositoryAgeMillis_withDefault() throws Exception { final CentralDogmaConfig cfg = Jackson.readValue("{\n" + " \"dataDir\": \"./data\",\n" + " \"ports\": [\n" + " {\n" + " \"localAddress\": {\n" + " \"host\": \"*\",\n" + " \"port\": 36462\n" + " },\n" + " \"protocols\": [\n" + " \"https\",\n" + " ... | @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } | CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } } | CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } CentralDogmaConfig(
@JsonProperty(value = "dataDir", required = true) File dataDir,
@JsonProperty(value = "ports", required = true)
@JsonDeserialize(contentUsing =... | CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } CentralDogmaConfig(
@JsonProperty(value = "dataDir", required = true) File dataDir,
@JsonProperty(value = "ports", required = true)
@JsonDeserialize(contentUsing =... | CentralDogmaConfig { @JsonProperty public long maxRemovedRepositoryAgeMillis() { return maxRemovedRepositoryAgeMillis; } CentralDogmaConfig(
@JsonProperty(value = "dataDir", required = true) File dataDir,
@JsonProperty(value = "ports", required = true)
@JsonDeserialize(contentUsing =... |
@Test void testValidateFilePath() { assertFilePathValidationSuccess("/foo.txt"); assertFilePathValidationSuccess("/foo/bar.txt"); assertFilePathValidationSuccess("/foo.bar/baz.json"); assertFilePathValidationSuccess("/foo-bar/baz-json"); assertFilePathValidationFailure("foo"); assertFilePathValidationFailure("/"); asse... | 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; } | 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; } } | 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(); } | 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 ... | 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 ... |
@Test void testValidateJsonFilePath() { assertJsonFilePathValidationSuccess("/foo.json"); assertJsonFilePathValidationSuccess("/foo/bar.json"); assertJsonFilePathValidationSuccess("/foo.bar/baz.json"); assertJsonFilePathValidationSuccess("/foo.JSON"); assertJsonFilePathValidationSuccess("/foo.Json"); assertJsonFilePath... | 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; } | 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; } } | 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(); } | 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); st... | 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); st... |
@Test void testValidateDirPath() { assertDirPathValidationSuccess("/"); assertDirPathValidationSuccess("/foo"); assertDirPathValidationSuccess("/foo/"); assertDirPathValidationSuccess("/foo/bar"); assertDirPathValidationSuccess("/foo/bar/"); assertDirPathValidationSuccess("/foo.bar/"); assertDirPathValidationSuccess("/... | 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; } | 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; } } | 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(); } | 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 isV... | 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 isV... |
@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(ava... | public static long availableTimeout(long expectedTimeoutMillis) { return availableTimeout(expectedTimeoutMillis, 0); } | WatchTimeout { public static long availableTimeout(long expectedTimeoutMillis) { return availableTimeout(expectedTimeoutMillis, 0); } } | WatchTimeout { public static long availableTimeout(long expectedTimeoutMillis) { return availableTimeout(expectedTimeoutMillis, 0); } private WatchTimeout(); } | 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); } | 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 ... |
@Test void normalizeRevision() { final Revision latestRevision = new Revision(2); for (int i = 1; i <= latestRevision.major(); i++) { final Revision revision = new Revision(i); when(delegate.normalizeRevision(any(), any(), any())).thenReturn(completedFuture(revision)); assertThat(dogma.normalizeRevision("foo", "bar", R... | @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { return delegate.normalizeRevision(projectName, repositoryName, rev... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { ... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { ... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { ... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { ... |
@Test void normalizeRevisionAndExecuteWithRetries() throws Exception { final Revision latestRevision = new Revision(3); when(delegate.normalizeRevision(any(), any(), any())).thenReturn(completedFuture(latestRevision)); when(delegate.getFile(any(), any(), any(), any(Query.class))).thenReturn( exceptionallyCompletedFutur... | private <T> CompletableFuture<T> normalizeRevisionAndExecuteWithRetries( String projectName, String repositoryName, Revision revision, Function<Revision, CompletableFuture<T>> taskRunner) { return normalizeRevision(projectName, repositoryName, revision) .thenCompose(normRev -> executeWithRetries( new Supplier<Completab... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { private <T> CompletableFuture<T> normalizeRevisionAndExecuteWithRetries( String projectName, String repositoryName, Revision revision, Function<Revision, CompletableFuture<T>> taskRunner) { return normalizeRevision(projectName, repositoryName, revision) ... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { private <T> CompletableFuture<T> normalizeRevisionAndExecuteWithRetries( String projectName, String repositoryName, Revision revision, Function<Revision, CompletableFuture<T>> taskRunner) { return normalizeRevision(projectName, repositoryName, revision) ... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { private <T> CompletableFuture<T> normalizeRevisionAndExecuteWithRetries( String projectName, String repositoryName, Revision revision, Function<Revision, CompletableFuture<T>> taskRunner) { return normalizeRevision(projectName, repositoryName, revision) ... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { private <T> CompletableFuture<T> normalizeRevisionAndExecuteWithRetries( String projectName, String repositoryName, Revision revision, Function<Revision, CompletableFuture<T>> taskRunner) { return normalizeRevision(projectName, repositoryName, revision) ... |
@Test void listRepositories() { final Revision latestRevision = new Revision(2); for (int i = 1; i <= latestRevision.major(); i++) { final Revision revision = new Revision(i); when(delegate.listRepositories(any())).thenReturn(completedFuture( ImmutableMap.of("bar", new RepositoryInfo("bar", revision)))); assertThat(dog... | @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { return executeWithRetries( new Supplier<CompletableFuture<Map<String, RepositoryInfo>>>() { @Override public CompletableFuture<Map<String, RepositoryInfo>> get() { return delegate.listRepositories(projectName); } @Ove... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { return executeWithRetries( new Supplier<CompletableFuture<Map<String, RepositoryInfo>>>() { @Override public CompletableFuture<Map<String, RepositoryIn... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { return executeWithRetries( new Supplier<CompletableFuture<Map<String, RepositoryInfo>>>() { @Override public CompletableFuture<Map<String, RepositoryIn... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { return executeWithRetries( new Supplier<CompletableFuture<Map<String, RepositoryInfo>>>() { @Override public CompletableFuture<Map<String, RepositoryIn... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { return executeWithRetries( new Supplier<CompletableFuture<Map<String, RepositoryInfo>>>() { @Override public CompletableFuture<Map<String, RepositoryIn... |
@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... | public static Entry<String> ofText(Revision revision, String path, String content) { return new Entry<>(revision, path, EntryType.TEXT, content); } | Entry implements ContentHolder<T> { public static Entry<String> ofText(Revision revision, String path, String content) { return new Entry<>(revision, path, EntryType.TEXT, content); } } | 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); } | 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, S... | 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, S... |
@Test void retryOnlyOnRevisionNotFoundException() { when(delegate.normalizeRevision(any(), any(), any())) .thenReturn(exceptionallyCompletedFuture(new ProjectNotFoundException())); assertThatThrownBy(() -> dogma.normalizeRevision("foo", "bar", Revision.HEAD).join()) .isInstanceOf(CompletionException.class) .hasCauseIns... | @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { return delegate.normalizeRevision(projectName, repositoryName, rev... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { ... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { ... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { ... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> normalizeRevision( String projectName, String repositoryName, Revision revision) { return executeWithRetries( new Supplier<CompletableFuture<Revision>>() { @Override public CompletableFuture<Revision> get() { ... |
@Test void push() { final PushResult pushResult = new PushResult(new Revision(3), 42L); when(delegate.push(any(), any(), any(), any(), any(), any(), any(Iterable.class))) .thenReturn(completedFuture(pushResult)); assertThat(dogma.push("foo", "bar", Revision.HEAD, "summary", "detail", Markup.MARKDOWN, ImmutableList.of(C... | @Override public CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes) { return executeWithRetries( new Supplier<CompletableFuture<PushResult>>() { @Override public CompletableFuture<Push... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes) { return executeWithRetries( new Supplier<Completa... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes) { return executeWithRetries( new Supplier<Completa... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes) { return executeWithRetries( new Supplier<Completa... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<PushResult> push( String projectName, String repositoryName, Revision baseRevision, String summary, String detail, Markup markup, Iterable<? extends Change<?>> changes) { return executeWithRetries( new Supplier<Completa... |
@Test void watchRepository() { final Revision latestRevision = new Revision(3); when(delegate.normalizeRevision(any(), any(), any())) .thenReturn(completedFuture(Revision.INIT)); when(delegate.watchRepository(any(), any(), any(), any(), anyLong())) .thenReturn(completedFuture(latestRevision)); assertThat(dogma.watchRep... | @Override public CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnownRevision, new Function<Revision, CompletableFuture<Revision>... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, las... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, las... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, las... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Revision> watchRepository( String projectName, String repositoryName, Revision lastKnownRevision, String pathPattern, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, las... |
@Test void watchFile() { final Revision latestRevision = new Revision(3); final Entry<String> latestEntry = Entry.ofText(latestRevision, "/a.txt", "a"); when(delegate.normalizeRevision(any(), any(), any())) .thenReturn(completedFuture(Revision.INIT)); when(delegate.watchFile(any(), any(), any(), (Query<String>) any(), ... | @Override public <T> CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnownRevision, new Function<Revision, CompletableFuture<Entry<T>>>() { ... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnown... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnown... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnown... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> watchFile( String projectName, String repositoryName, Revision lastKnownRevision, Query<T> query, long timeoutMillis) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, lastKnown... |
@Test void getFile() { final Revision latestRevision = new Revision(3); final Entry<String> latestEntry = Entry.ofText(latestRevision, "/a.txt", "a"); when(delegate.normalizeRevision(any(), any(), any())) .thenReturn(completedFuture(latestRevision)); when(delegate.getFile(any(), any(), any(), any(Query.class))) .thenAn... | @Override public <T> CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, revision, new Function<Revision, CompletableFuture<Entry<T>>>() { @Override public CompletableFuture<Entry... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, revision, new Function<Revision, Complet... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, revision, new Function<Revision, Complet... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, revision, new Function<Revision, Complet... | ReplicationLagTolerantCentralDogma extends AbstractCentralDogma { @Override public <T> CompletableFuture<Entry<T>> getFile( String projectName, String repositoryName, Revision revision, Query<T> query) { return normalizeRevisionAndExecuteWithRetries( projectName, repositoryName, revision, new Function<Revision, Complet... |
@Test void testEncodePathPattern() { assertThat(encodePathPattern("/")).isEqualTo("/"); assertThat(encodePathPattern(" ")).isEqualTo("%20"); assertThat(encodePathPattern(" ")).isEqualTo("%20%20"); assertThat(encodePathPattern("a b")).isEqualTo("a%20b"); assertThat(encodePathPattern(" a ")).isEqualTo("%20a%20"); final S... | @VisibleForTesting static String encodePathPattern(String pathPattern) { int spacePos = pathPattern.indexOf(' '); if (spacePos < 0) { return pathPattern; } final StringBuilder buf = new StringBuilder(IntMath.saturatedMultiply(pathPattern.length(), 2)); for (int pos = 0;;) { buf.append(pathPattern, pos, spacePos); buf.a... | ArmeriaCentralDogma extends AbstractCentralDogma { @VisibleForTesting static String encodePathPattern(String pathPattern) { int spacePos = pathPattern.indexOf(' '); if (spacePos < 0) { return pathPattern; } final StringBuilder buf = new StringBuilder(IntMath.saturatedMultiply(pathPattern.length(), 2)); for (int pos = 0... | ArmeriaCentralDogma extends AbstractCentralDogma { @VisibleForTesting static String encodePathPattern(String pathPattern) { int spacePos = pathPattern.indexOf(' '); if (spacePos < 0) { return pathPattern; } final StringBuilder buf = new StringBuilder(IntMath.saturatedMultiply(pathPattern.length(), 2)); for (int pos = 0... | ArmeriaCentralDogma extends AbstractCentralDogma { @VisibleForTesting static String encodePathPattern(String pathPattern) { int spacePos = pathPattern.indexOf(' '); if (spacePos < 0) { return pathPattern; } final StringBuilder buf = new StringBuilder(IntMath.saturatedMultiply(pathPattern.length(), 2)); for (int pos = 0... | ArmeriaCentralDogma extends AbstractCentralDogma { @VisibleForTesting static String encodePathPattern(String pathPattern) { int spacePos = pathPattern.indexOf(' '); if (spacePos < 0) { return pathPattern; } final StringBuilder buf = new StringBuilder(IntMath.saturatedMultiply(pathPattern.length(), 2)); for (int pos = 0... |
@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); } | @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); } | 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 ... | 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 ... | 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 ... | 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 ... |
@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); } | @Override public List<Endpoint> decode(String object) { return convertToEndpointList(NEWLINE_SPLITTER.splitToList(object)); } | TextEndpointListDecoder implements EndpointListDecoder<String> { @Override public List<Endpoint> decode(String object) { return convertToEndpointList(NEWLINE_SPLITTER.splitToList(object)); } } | TextEndpointListDecoder implements EndpointListDecoder<String> { @Override public List<Endpoint> decode(String object) { return convertToEndpointList(NEWLINE_SPLITTER.splitToList(object)); } } | TextEndpointListDecoder implements EndpointListDecoder<String> { @Override public List<Endpoint> decode(String object) { return convertToEndpointList(NEWLINE_SPLITTER.splitToList(object)); } @Override List<Endpoint> decode(String object); } | TextEndpointListDecoder implements EndpointListDecoder<String> { @Override public List<Endpoint> decode(String object) { return convertToEndpointList(NEWLINE_SPLITTER.splitToList(object)); } @Override List<Endpoint> decode(String object); } |
@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 StringBuil... | 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 EventLoopGr... | ArmeriaCentralDogmaBuilder extends AbstractArmeriaCentralDogmaBuilder<ArmeriaCentralDogmaBuilder> { public CentralDogma build() throws UnknownHostException { final EndpointGroup endpointGroup = endpointGroup(); final String scheme = "none+" + (isUseTls() ? "https" : "http"); final ClientBuilder builder = newClientBuild... | ArmeriaCentralDogmaBuilder extends AbstractArmeriaCentralDogmaBuilder<ArmeriaCentralDogmaBuilder> { public CentralDogma build() throws UnknownHostException { final EndpointGroup endpointGroup = endpointGroup(); final String scheme = "none+" + (isUseTls() ? "https" : "http"); final ClientBuilder builder = newClientBuild... | ArmeriaCentralDogmaBuilder extends AbstractArmeriaCentralDogmaBuilder<ArmeriaCentralDogmaBuilder> { public CentralDogma build() throws UnknownHostException { final EndpointGroup endpointGroup = endpointGroup(); final String scheme = "none+" + (isUseTls() ? "https" : "http"); final ClientBuilder builder = newClientBuild... | ArmeriaCentralDogmaBuilder extends AbstractArmeriaCentralDogmaBuilder<ArmeriaCentralDogmaBuilder> { public CentralDogma build() throws UnknownHostException { final EndpointGroup endpointGroup = endpointGroup(); final String scheme = "none+" + (isUseTls() ? "https" : "http"); final ClientBuilder builder = newClientBuild... |
@Test void execute() throws Exception { check("listProjects", 1000L, 1L, 1L); } | @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> ... | 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".eq... | 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".eq... | 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".eq... | 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".eq... |
@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\" }")); assertThatJso... | public static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content) { return new Entry<>(revision, path, EntryType.JSON, content); } | Entry implements ContentHolder<T> { public static Entry<JsonNode> ofJson(Revision revision, String path, JsonNode content) { return new Entry<>(revision, path, EntryType.JSON, content); } } | 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); } | 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 revisio... | 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 revisio... |
@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("pro... | @Override public CompletableFuture<Void> createProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.createProject(projectName, callback); }); } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.createProject(projectName, callback); }); } } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.createProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIfac... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.createProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIfac... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.createProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIfac... |
@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("pro... | @Override public CompletableFuture<Void> removeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.removeProject(projectName, callback); }); } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.removeProject(projectName, callback); }); } } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.removeProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIfac... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.removeProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIfac... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.removeProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIfac... |
@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... | @Override public CompletableFuture<Void> purgeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.purgeProject(projectName, callback); }); } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.purgeProject(projectName, callback); }); } } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.purgeProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface ... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.purgeProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface ... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.purgeProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface ... |
@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... | @Override public CompletableFuture<Void> unremoveProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.unremoveProject(projectName, callback); }); } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.unremoveProject(projectName, callback); }); } } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.unremoveProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.Async... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.unremoveProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.Async... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveProject(String projectName) { return run(callback -> { validateProjectName(projectName); client.unremoveProject(projectName, callback); }); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.Async... |
@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(Immutable... | @Override public CompletableFuture<Set<String>> listProjects() { final CompletableFuture<List<Project>> future = run(client::listProjects); return future.thenApply(list -> convertToSet(list, Project::getName)); } | 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 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, Cen... | 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, Cen... | 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, Cen... |
@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(Immu... | @Override public CompletableFuture<Set<String>> listRemovedProjects() { return run(client::listRemovedProjects); } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Set<String>> listRemovedProjects() { return run(client::listRemovedProjects); } } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Set<String>> listRemovedProjects() { return run(client::listRemovedProjects); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Set<String>> listRemovedProjects() { return run(client::listRemovedProjects); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projec... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Set<String>> listRemovedProjects() { return run(client::listRemovedProjects); } LegacyCentralDogma(ScheduledExecutorService executor, CentralDogmaService.AsyncIface client); @Override CompletableFuture<Void> createProject(String projec... |
@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();... | @Override public CompletableFuture<Void> createRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.createRepository(projectName, repositoryName, callback); }); } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.createRepository(projectName, repositoryName, callback); }); } } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.createRepository(projectName, repositoryName, callback); }); } LegacyCen... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.createRepository(projectName, repositoryName, callback); }); } LegacyCen... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> createRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.createRepository(projectName, repositoryName, callback); }); } LegacyCen... |
@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();... | @Override public CompletableFuture<Void> removeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.removeRepository(projectName, repositoryName, callback); }); } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.removeRepository(projectName, repositoryName, callback); }); } } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.removeRepository(projectName, repositoryName, callback); }); } LegacyCen... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.removeRepository(projectName, repositoryName, callback); }); } LegacyCen... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> removeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.removeRepository(projectName, repositoryName, callback); }); } LegacyCen... |
@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(); ve... | @Override public CompletableFuture<Void> purgeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.purgeRepository(projectName, repositoryName, callback); }); } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.purgeRepository(projectName, repositoryName, callback); }); } } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.purgeRepository(projectName, repositoryName, callback); }); } LegacyCentr... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.purgeRepository(projectName, repositoryName, callback); }); } LegacyCentr... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> purgeRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.purgeRepository(projectName, repositoryName, callback); }); } LegacyCentr... |
@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()).isN... | @Override public CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.unremoveRepository(projectName, repositoryName, callback); }); } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.unremoveRepository(projectName, repositoryName, callback); }); } } | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.unremoveRepository(projectName, repositoryName, callback); }); } Legac... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.unremoveRepository(projectName, repositoryName, callback); }); } Legac... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Void> unremoveRepository(String projectName, String repositoryName) { return run(callback -> { validateProjectAndRepositoryName(projectName, repositoryName); client.unremoveRepository(projectName, repositoryName, callback); }); } Legac... |
@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... | public static <T> Entry<T> of(Revision revision, String path, EntryType type, @Nullable T content) { return new Entry<>(revision, path, type, content); } | 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); } } | 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); } | 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 revis... | 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 revis... |
@Test void listRepositories() throws Exception { doAnswer(invocation -> { final AsyncMethodCallback<List<Repository>> callback = invocation.getArgument(1); final Repository repository = new Repository("repo").setHead( new TCommit(new TRevision(42), new TAuthor("hitchhiker", "arthur@dent.com"), "1978-03-08T00:00:00Z", "... | @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { final CompletableFuture<List<Repository>> future = run(callback -> { validateProjectName(projectName); client.listRepositories(projectName, callback); }); return future.thenApply(list -> convertToMap( list, Function.i... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { final CompletableFuture<List<Repository>> future = run(callback -> { validateProjectName(projectName); client.listRepositories(projectName, callback); }); return futur... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { final CompletableFuture<List<Repository>> future = run(callback -> { validateProjectName(projectName); client.listRepositories(projectName, callback); }); return futur... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { final CompletableFuture<List<Repository>> future = run(callback -> { validateProjectName(projectName); client.listRepositories(projectName, callback); }); return futur... | LegacyCentralDogma extends AbstractCentralDogma { @Override public CompletableFuture<Map<String, RepositoryInfo>> listRepositories(String projectName) { final CompletableFuture<List<Repository>> future = run(callback -> { validateProjectName(projectName); client.listRepositories(projectName, callback); }); return futur... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.