Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
PriceRequestBuilder extends AbstractStocksRequestBuilder<BigDecimal, PriceRequestBuilder> implements IEXCloudV1RestRequest<BigDecimal> { @Override public RestRequest<BigDecimal> build() { return RestRequestBuilder.<BigDecimal>builder() .withPath("/stock/{symbol}/price") .addPathParam("symbol", getSymbol()).get() .withResponse(BigDecimal.class) .build(); } @Override RestRequest<BigDecimal> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<BigDecimal> request = new PriceRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/price"); assertThat(request.getResponseType()).isEqualTo(new GenericType<BigDecimal>() {}); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
SetUtil { public static <T> Set<T> immutableSet(final Collection<? extends T> elements) { return elements == null ? ImmutableSet.of() : ImmutableSet.copyOf(elements); } private SetUtil(); static Set<T> immutableSet(final Collection<? extends T> elements); }
@Test public void shouldCreateEmptySetForNullInput() { final Set<String> result = SetUtil.immutableSet(null); assertThat(result).isEmpty(); } @Test public void shouldCreateImmutableSetFromSet() { final Set<String> mutableSet = new HashSet<>(); final Set<String> immutableSet = SetUtil.immutableSet(mutableSet); assertThat(immutableSet).isInstanceOf(ImmutableSet.class); }
OhlcRequestBuilder extends AbstractStocksRequestBuilder<Ohlc, OhlcRequestBuilder> implements IEXApiRestRequest<Ohlc>, IEXCloudV1RestRequest<Ohlc> { @Override public RestRequest<Ohlc> build() { return RestRequestBuilder.<Ohlc>builder() .withPath("/stock/{symbol}/ohlc") .addPathParam("symbol", getSymbol()).get() .withResponse(Ohlc.class) .build(); } @Override RestRequest<Ohlc> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<Ohlc> request = new OhlcRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/ohlc"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Ohlc>() {}); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
TodayEarningsRequestBuilder implements IEXCloudV1RestRequest<TodayEarnings> { @Override public RestRequest<TodayEarnings> build() { return RestRequestBuilder.<TodayEarnings>builder() .withPath("/stock/market/today-earnings").get() .withResponse(TodayEarnings.class) .build(); } @Override RestRequest<TodayEarnings> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final RestRequest<TodayEarnings> request = new TodayEarningsRequestBuilder() .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/market/today-earnings"); assertThat(request.getResponseType()).isEqualTo(new GenericType<TodayEarnings>() {}); assertThat(request.getQueryParams()).isEmpty(); }
OhlcMarketRequestBuilder implements IEXApiRestRequest<Map<String, Ohlc>>, IEXCloudV1RestRequest<Map<String, Ohlc>> { @Override public RestRequest<Map<String, Ohlc>> build() { return RestRequestBuilder.<Map<String, Ohlc>>builder() .withPath("/stock/{symbol}/ohlc") .addPathParam("symbol", "market").get() .withResponse(new GenericType<Map<String, Ohlc>>(){}) .build(); } @Override RestRequest<Map<String, Ohlc>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final RestRequest<Map<String, Ohlc>> request = new OhlcMarketRequestBuilder() .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/ohlc"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Map<String, Ohlc>>() {}); assertThat(request.getPathParams()).containsExactly(entry("symbol", "market")); assertThat(request.getQueryParams()).isEmpty(); }
BookRequestBuilder extends AbstractStocksRequestBuilder<Book, BookRequestBuilder> implements IEXApiRestRequest<Book>, IEXCloudV1RestRequest<Book> { @Override public RestRequest<Book> build() { return RestRequestBuilder.<Book>builder() .withPath("/stock/{symbol}/book") .addPathParam("symbol", getSymbol()).get() .withResponse(Book.class) .build(); } @Override RestRequest<Book> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<Book> request = new BookRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/book"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Book>() {}); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
PeersRequestBuilder extends AbstractStocksRequestBuilder<List<String>, PeersRequestBuilder> implements IEXCloudV1RestRequest<List<String>> { @Override public RestRequest<List<String>> build() { return RestRequestBuilder.<List<String>>builder() .withPath("/stock/{symbol}/peers") .addPathParam("symbol", getSymbol()).get() .withResponse(new GenericType<List<String>>() {}) .build(); } @Override RestRequest<List<String>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<List<String>> request = new PeersRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/peers"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<String>>() {}); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
SectorPerformanceRequestBuilder implements IEXCloudV1RestRequest<List<SectorPerformance>> { @Override public RestRequest<List<SectorPerformance>> build() { return RestRequestBuilder.<List<SectorPerformance>>builder() .withPath("/stock/market/sector-performance").get() .withResponse(new GenericType<List<SectorPerformance>>(){}) .build(); } @Override RestRequest<List<SectorPerformance>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final RestRequest<List<SectorPerformance>> request = new SectorPerformanceRequestBuilder() .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/market/sector-performance"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<SectorPerformance>>() {}); assertThat(request.getQueryParams()).isEmpty(); }
QuoteRequestBuilder extends AbstractStocksRequestBuilder<Quote, QuoteRequestBuilder> implements IEXCloudV1RestRequest<Quote> { @Override public RestRequest<Quote> build() { return RestRequestBuilder.<Quote>builder() .withPath("/stock/{symbol}/quote") .addPathParam("symbol", getSymbol()).get() .withResponse(Quote.class) .addQueryParam("displayPercent", String.valueOf(displayPercent)) .build(); } QuoteRequestBuilder withDisplayPercent(); @Override RestRequest<Quote> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<Quote> request = new QuoteRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/quote"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Quote>() {}); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).containsExactly(entry("displayPercent", "false")); }
PreviousMarketRequestBuilder implements IEXCloudV1RestRequest<Map<String, BarData>> { @Override public RestRequest<Map<String, BarData>> build() { return RestRequestBuilder.<Map<String, BarData>>builder() .withPath("/stock/{symbol}/previous") .addPathParam("symbol", "market").get() .withResponse(new GenericType<Map<String, BarData>>(){}) .build(); } @Override RestRequest<Map<String, BarData>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final RestRequest<Map<String, BarData>> request = new PreviousMarketRequestBuilder() .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/previous"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Map<String, BarData>>() { }); assertThat(request.getPathParams()).containsExactly(entry("symbol", "market")); assertThat(request.getQueryParams()).isEmpty(); }
InsiderTransactionRequestBuilder extends AbstractStocksRequestBuilder<List<InsiderTransaction>, InsiderTransactionRequestBuilder> implements IEXCloudV1RestRequest<List<InsiderTransaction>> { @Override public RestRequest<List<InsiderTransaction>> build() { return RestRequestBuilder.<List<InsiderTransaction>>builder() .withPath("/stock/{symbol}/insider-transactions") .addPathParam("symbol", getSymbol()).get() .withResponse(new GenericType<List<InsiderTransaction>>() {}) .build(); } @Override RestRequest<List<InsiderTransaction>> build(); }
@Test public void shouldSuccessfullyCreateInsiderTransactionRequest() { final String symbol = "AAPL"; final RestRequest<List<InsiderTransaction>> request = new InsiderTransactionRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/insider-transactions"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<InsiderTransaction>>() { }); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
KeyStatsRequestBuilder extends AbstractStocksRequestBuilder<KeyStats, KeyStatsRequestBuilder> implements IEXCloudV1RestRequest<KeyStats> { @Override public RestRequest<KeyStats> build() { return RestRequestBuilder.<KeyStats>builder() .withPath("/stock/{symbol}/stats") .addPathParam(SYMBOL_PARAM_NAME, getSymbol()).get() .withResponse(KeyStats.class) .build(); } @Override RestRequest<KeyStats> build(); }
@Test public void shouldSuccessfullyCreateKeyStatsRequest() { final String symbol = "AAPL"; final RestRequest<KeyStats> request = new KeyStatsRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/stats"); assertThat(request.getResponseType()).isEqualTo(new GenericType<KeyStats>() { }); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
PreviousRequestBuilder extends AbstractStocksRequestBuilder<BarData, PreviousRequestBuilder> implements IEXCloudV1RestRequest<BarData> { @Override public RestRequest<BarData> build() { return RestRequestBuilder.<BarData>builder() .withPath("/stock/{symbol}/previous") .addPathParam("symbol", getSymbol()).get() .withResponse(BarData.class) .build(); } @Override RestRequest<BarData> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<BarData> request = new PreviousRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/previous"); assertThat(request.getResponseType()).isEqualTo(new GenericType<BarData>() { }); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
BatchStocksRequestBuilder extends AbstractBatchStocksRequestBuilder<BatchStocks, BatchStocksRequestBuilder> { @Override public RestRequest<BatchStocks> build() { processTypes(); return RestRequestBuilder.<BatchStocks>builder() .withPath("/stock/{symbol}/batch") .addPathParam("symbol", getSymbol()).get() .withResponse(BatchStocks.class) .addQueryParam(getQueryParameters()) .build(); } @Override RestRequest<BatchStocks> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final BatchStocksType stocksType = BatchStocksType.NEWS; final RestRequest<BatchStocks> request = new BatchStocksRequestBuilder() .addType(stocksType) .withSymbol(symbol) .withLast(5) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/batch"); assertThat(request.getResponseType()).isEqualTo(new GenericType<BatchStocks>() { }); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).contains(entry("types", "news"), entry("last", "5")); }
SplitsRequestBuilder extends AbstractStocksRequestBuilder<List<Split>, SplitsRequestBuilder> { @Override public RestRequest<List<Split>> build() { return RestRequestBuilder.<List<Split>>builder() .withPath("/stock/{symbol}/splits/{range}") .addPathParam("symbol", getSymbol()) .addPathParam("range", getSplitsRange().getCode()).get() .withResponse(new GenericType<List<Split>>() { }) .build(); } SplitsRange getSplitsRange(); SplitsRequestBuilder withSplitsRange(final SplitsRange splitsRange); @Override RestRequest<List<Split>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<List<Split>> request = new SplitsRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/splits/{range}"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<Split>>() { }); assertThat(request.getPathParams()).containsExactly( entry("symbol", symbol), entry("range", SplitsRange.ONE_MONTH.getCode())); assertThat(request.getQueryParams()).isEmpty(); }
PriceTargetRequestBuilder extends AbstractStocksRequestBuilder<PriceTarget, PriceTargetRequestBuilder> implements IEXCloudV1RestRequest<PriceTarget> { @Override public RestRequest<PriceTarget> build() { return RestRequestBuilder.<PriceTarget>builder() .withPath("/stock/{symbol}/price-target") .addPathParam(SYMBOL_PARAM_NAME, getSymbol()).get() .withResponse(PriceTarget.class) .build(); } @Override RestRequest<PriceTarget> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<PriceTarget> request = new PriceTargetRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/price-target"); assertThat(request.getResponseType()).isEqualTo(new GenericType<PriceTarget>() { }); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
RecommendationTrendsRequestBuilder extends AbstractStocksRequestBuilder<List<RecommendationTrends>, RecommendationTrendsRequestBuilder> implements IEXCloudV1RestRequest<List<RecommendationTrends>> { @Override public RestRequest<List<RecommendationTrends>> build() { return RestRequestBuilder.<List<RecommendationTrends>>builder() .withPath("/stock/{symbol}/recommendation-trends") .addPathParam(SYMBOL_PARAM_NAME, getSymbol()).get() .withResponse(new GenericType<List<RecommendationTrends>>() {}) .build(); } @Override RestRequest<List<RecommendationTrends>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<List<RecommendationTrends>> request = new RecommendationTrendsRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/recommendation-trends"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<RecommendationTrends>>() { }); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
IntradayRequestBuilder extends AbstractChartRequestBuilder<List<Intraday>, IntradayRequestBuilder> implements IEXCloudV1RestRequest<List<Intraday>> { @Override public RestRequest<List<Intraday>> build() { return RestRequestBuilder.<List<Intraday>>builder() .withPath("/stock/{symbol}/intraday-prices") .addPathParam("symbol", getSymbol()).get() .withResponse(new GenericType<List<Intraday>>() {}) .addQueryParam(this.queryParameters) .build(); } IntradayRequestBuilder withChartIEXOnly(); @Override RestRequest<List<Intraday>> build(); }
@Test public void shouldSuccessfullyCreateIntradayRequest() { final String symbol = "AAPL"; final RestRequest<List<Intraday>> request = new IntradayRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/intraday-prices"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<Intraday>>() { }); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
InsiderSummaryRequestBuilder extends AbstractStocksRequestBuilder<List<InsiderSummary>, InsiderSummaryRequestBuilder> implements IEXCloudV1RestRequest<List<InsiderSummary>> { @Override public RestRequest<List<InsiderSummary>> build() { return RestRequestBuilder.<List<InsiderSummary>>builder() .withPath("/stock/{symbol}/insider-summary") .addPathParam("symbol", getSymbol()).get() .withResponse(new GenericType<List<InsiderSummary>>() {}) .build(); } @Override RestRequest<List<InsiderSummary>> build(); }
@Test public void shouldSuccessfullyCreateInsiderSummaryRequest() { final String symbol = "AAPL"; final RestRequest<List<InsiderSummary>> request = new InsiderSummaryRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/insider-summary"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<InsiderSummary>>() { }); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
FundOwnershipRequestBuilder extends AbstractStocksRequestBuilder<List<FundOwnership>, FundOwnershipRequestBuilder> implements IEXCloudV1RestRequest<List<FundOwnership>> { @Override public RestRequest<List<FundOwnership>> build() { return RestRequestBuilder.<List<FundOwnership>>builder() .withPath("/stock/{symbol}/fund-ownership") .addPathParam("symbol", getSymbol()).get() .withResponse(new GenericType<List<FundOwnership>>() {}) .build(); } @Override RestRequest<List<FundOwnership>> build(); }
@Test public void shouldSuccessfullyCreateFundOwnershipRequest() { final String symbol = "AAPL"; final RestRequest<List<FundOwnership>> request = new FundOwnershipRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/fund-ownership"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<FundOwnership>>() { }); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
InstitutionalOwnershipRequestBuilder extends AbstractStocksRequestBuilder<List<Ownership>, InstitutionalOwnershipRequestBuilder> implements IEXCloudV1RestRequest<List<Ownership>> { @Override public RestRequest<List<Ownership>> build() { return RestRequestBuilder.<List<Ownership>>builder() .withPath("/stock/{symbol}/institutional-ownership") .addPathParam("symbol", getSymbol()).get() .withResponse(new GenericType<List<Ownership>>() { }) .build(); } @Override RestRequest<List<Ownership>> build(); }
@Test public void shouldSuccessfullyCreateInstitutionalOwnershipRequest() { final String symbol = "AAPL"; final RestRequest<List<Ownership>> request = new InstitutionalOwnershipRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/institutional-ownership"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<Ownership>>() { }); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
AdvancedStatsRequestBuilder extends AbstractStocksRequestBuilder<AdvancedStats, AdvancedStatsRequestBuilder> implements IEXCloudV1RestRequest<AdvancedStats> { @Override public RestRequest<AdvancedStats> build() { return RestRequestBuilder.<AdvancedStats>builder() .withPath("/stock/{symbol}/advanced-stats") .addPathParam(SYMBOL_PARAM_NAME, getSymbol()).get() .withResponse(AdvancedStats.class) .build(); } @Override RestRequest<AdvancedStats> build(); }
@Test public void shouldSuccessfullyCreateAdvancedStatsRequest() { final String symbol = "AAPL"; final RestRequest<AdvancedStats> request = new AdvancedStatsRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/advanced-stats"); assertThat(request.getResponseType()).isEqualTo(new GenericType<AdvancedStats>() { }); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
ListUtil { public static <T> List<T> immutableList(final Collection<? extends T> elements) { return elements == null ? ImmutableList.of() : ImmutableList.copyOf(elements); } private ListUtil(); static List<T> immutableList(final Collection<? extends T> elements); }
@Test public void shouldCreateEmptyListForNullInput() { final List<String> result = ListUtil.immutableList(null); assertThat(result).isEmpty(); } @Test public void shouldCreateImmutableListFromList() { final List<String> mutableList = new ArrayList<>(); final List<String> immutableList = ListUtil.immutableList(mutableList); assertThat(immutableList).isInstanceOf(ImmutableList.class); }
InsiderRosterRequestBuilder extends AbstractStocksRequestBuilder<List<InsiderRoster>, InsiderRosterRequestBuilder> implements IEXCloudV1RestRequest<List<InsiderRoster>> { @Override public RestRequest<List<InsiderRoster>> build() { return RestRequestBuilder.<List<InsiderRoster>>builder() .withPath("/stock/{symbol}/insider-roster") .addPathParam("symbol", getSymbol()).get() .withResponse(new GenericType<List<InsiderRoster>>() {}) .build(); } @Override RestRequest<List<InsiderRoster>> build(); }
@Test public void shouldSuccessfullyCreateInsiderRosterRequest() { final String symbol = "AAPL"; final RestRequest<List<InsiderRoster>> request = new InsiderRosterRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/insider-roster"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<InsiderRoster>>() { }); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
TodayIposRequestBuilder implements IEXCloudV1RestRequest<TodayIpos> { @Override public RestRequest<TodayIpos> build() { return RestRequestBuilder.<TodayIpos>builder() .withPath("/stock/market/today-ipos").get() .withResponse(TodayIpos.class) .build(); } @Override RestRequest<TodayIpos> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final RestRequest<TodayIpos> request = new TodayIposRequestBuilder() .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/market/today-ipos"); assertThat(request.getResponseType()).isEqualTo(new GenericType<TodayIpos>() {}); assertThat(request.getQueryParams()).isEmpty(); }
TimeSeriesRequestBuilder implements IEXCloudV1RestRequest<List<TimeSeriesMetadata>> { @Override public RestRequest<List<TimeSeriesMetadata>> build() { return RestRequestBuilder.<List<TimeSeriesMetadata>>builder() .withPath("/time-series").get() .withResponse(new GenericType<List<TimeSeriesMetadata>>() {}) .build(); } KeyTimeSeriesRequestBuilder withId(final String id); @Override RestRequest<List<TimeSeriesMetadata>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final RestRequest<List<TimeSeriesMetadata>> request = new TimeSeriesRequestBuilder() .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/time-series"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<TimeSeriesMetadata>>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).isEmpty(); }
DataPointsRequestBuilder extends AbstractStocksRequestBuilder<List<DataPoint>, DataPointsRequestBuilder> implements IEXCloudV1RestRequest<List<DataPoint>> { @Override public RestRequest<List<DataPoint>> build() { return RestRequestBuilder.<List<DataPoint>>builder() .withPath("/data-points/{symbol}") .addPathParam("symbol", getSymbol()).get() .withResponse(new GenericType<List<DataPoint>>() {}) .build(); } KeyDataPointRequestBuilder withKey(final String key); @Override RestRequest<List<DataPoint>> build(); }
@Test public void shouldSuccessfullyCreateDataPointsRequest() { final String symbol = "AAPL"; final RestRequest<List<DataPoint>> request = new DataPointsRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/data-points/{symbol}"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<DataPoint>>() { }); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
TradeBreakRequestBuilder extends AbstractMarketDataRequestBuilder<Map<String, List<Trade>>, TradeBreakRequestBuilder> implements IEXApiRestRequest<Map<String, List<Trade>>>, IEXCloudV1RestRequest<Map<String, List<Trade>>> { @Override public RestRequest<Map<String, List<Trade>>> build() { return RestRequestBuilder.<Map<String, List<Trade>>>builder() .withPath("/deep/trade-breaks").get() .withResponse(new GenericType<Map<String, List<Trade>>>() {}) .addQueryParam(getSymbols()) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<Map<String, List<Trade>>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<Map<String, List<Trade>>> request = new TradeBreakRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/deep/trade-breaks"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Map<String, List<Trade>>>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).contains(entry("symbols", symbol)); }
SystemEventRequestBuilder extends AbstractMarketDataRequestBuilder<SystemEvent, SystemEventRequestBuilder> implements IEXApiRestRequest<SystemEvent>, IEXCloudV1RestRequest<SystemEvent> { @Override public RestRequest<SystemEvent> build() { return RestRequestBuilder.<SystemEvent>builder() .withPath("/deep/system-event").get() .withResponse(SystemEvent.class) .addQueryParam(getSymbols()) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<SystemEvent> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<SystemEvent> request = new SystemEventRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/deep/system-event"); assertThat(request.getResponseType()).isEqualTo(new GenericType<SystemEvent>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).contains(entry("symbols", symbol)); }
OfficialPriceRequestBuilder extends AbstractMarketDataRequestBuilder<Map<String, OfficialPrice>, OfficialPriceRequestBuilder> implements IEXApiRestRequest<Map<String, OfficialPrice>>, IEXCloudV1RestRequest<Map<String, OfficialPrice>> { @Override public RestRequest<Map<String, OfficialPrice>> build() { return RestRequestBuilder.<Map<String, OfficialPrice>>builder() .withPath("/deep/official-price").get() .withResponse(new GenericType<Map<String, OfficialPrice>>() {}) .addQueryParam(getSymbols()) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<Map<String, OfficialPrice>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<Map<String, OfficialPrice>> request = new OfficialPriceRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/deep/official-price"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Map<String, OfficialPrice>>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).contains(entry("symbols", symbol)); }
AuctionRequestBuilder extends AbstractMarketDataRequestBuilder<Map<String, Auction>, AuctionRequestBuilder> implements IEXApiRestRequest<Map<String, Auction>>, IEXCloudV1RestRequest<Map<String, Auction>> { @Override public RestRequest<Map<String, Auction>> build() { return RestRequestBuilder.<Map<String, Auction>>builder() .withPath("/deep/auction").get() .withResponse(new GenericType<Map<String, Auction>>() {}) .addQueryParam(getSymbols()) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<Map<String, Auction>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<Map<String, Auction>> request = new AuctionRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/deep/auction"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Map<String, Auction>>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).contains(entry("symbols", symbol)); }
DeepRequestBuilder extends AbstractMarketDataRequestBuilder<DEEP, DeepRequestBuilder> implements IEXApiRestRequest<DEEP>, IEXCloudV1RestRequest<DEEP> { @Override public RestRequest<DEEP> build() { return RestRequestBuilder.<DEEP>builder() .withPath("/deep").get() .withResponse(DEEP.class) .addQueryParam(getSymbols()) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<DEEP> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<DEEP> request = new DeepRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/deep"); assertThat(request.getResponseType()).isEqualTo(new GenericType<DEEP>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).contains(entry("symbols", symbol)); }
SecurityEventRequestBuilder extends AbstractMarketDataRequestBuilder<Map<String, SecurityEvent>, SecurityEventRequestBuilder> implements IEXApiRestRequest<Map<String, SecurityEvent>>, IEXCloudV1RestRequest<Map<String, SecurityEvent>> { @Override public RestRequest<Map<String, SecurityEvent>> build() { return RestRequestBuilder.<Map<String, SecurityEvent>>builder() .withPath("/deep/security-event").get() .withResponse(new GenericType<Map<String, SecurityEvent>>() {}) .addQueryParam(getSymbols()) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<Map<String, SecurityEvent>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<Map<String, SecurityEvent>> request = new SecurityEventRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/deep/security-event"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Map<String, SecurityEvent>>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).contains(entry("symbols", symbol)); }
TradeRequestBuilder extends AbstractMarketDataRequestBuilder<Map<String, List<Trade>>, TradeRequestBuilder> implements IEXApiRestRequest<Map<String, List<Trade>>>, IEXCloudV1RestRequest<Map<String, List<Trade>>> { @Override public RestRequest<Map<String, List<Trade>>> build() { return RestRequestBuilder.<Map<String, List<Trade>>>builder() .withPath("/deep/trades").get() .withResponse(new GenericType<Map<String, List<Trade>>>() {}) .addQueryParam(getSymbols()) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<Map<String, List<Trade>>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<Map<String, List<Trade>>> request = new TradeRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/deep/trades"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Map<String, List<Trade>>>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).contains(entry("symbols", symbol)); }
LastTradeRequestBuilder extends AbstractMarketDataRequestBuilder<List<LastTrade>, LastTradeRequestBuilder> implements IEXApiRestRequest<List<LastTrade>>, IEXCloudV1RestRequest<List<LastTrade>> { @Override public RestRequest<List<LastTrade>> build() { return RestRequestBuilder.<List<LastTrade>>builder() .withPath("/tops/last").get() .withResponse(new GenericType<List<LastTrade>>() {}) .addQueryParam(getSymbols()) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<List<LastTrade>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<List<LastTrade>> request = new LastTradeRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/tops/last"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<LastTrade>>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).contains(entry("symbols", symbol)); }
TopsRequestBuilder extends AbstractMarketDataRequestBuilder<List<TOPS>, TopsRequestBuilder> implements IEXApiRestRequest<List<TOPS>>, IEXCloudV1RestRequest<List<TOPS>> { @Override public RestRequest<List<TOPS>> build() { return RestRequestBuilder.<List<TOPS>>builder() .withPath("/tops").get() .withResponse(new GenericType<List<TOPS>>() {}) .addQueryParam(getSymbols()) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<List<TOPS>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<List<TOPS>> request = new TopsRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/tops"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<TOPS>>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).contains(entry("symbols", symbol)); } @Test public void shouldSuccessfullyCreateRequestWithMultipleSymbols() { final String firstSymbol = "IBM"; final String secondSymbol = "MSFT"; final RestRequest<List<TOPS>> request = new TopsRequestBuilder() .withSymbols(firstSymbol, secondSymbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/tops"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<TOPS>>() {}); assertThat(request.getPathParams()).isEmpty(); final Map<String, String> queryParams = request.getQueryParams(); final String symbols = queryParams.get("symbols"); assertThat(symbols).contains(firstSymbol, secondSymbol); } @Test public void shouldSuccessfullyCreateRequestWithAllSymbols() { final RestRequest<List<TOPS>> request = new TopsRequestBuilder() .withAllSymbols() .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/tops"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<TOPS>>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).contains(entry("symbols", ALL_SYMBOLS)); }
HistRequestBuilder extends AbstractRequestFilterBuilder<Map<String, List<HIST>>, HistRequestBuilder> { @Override public RestRequest<Map<String, List<HIST>>> build() { return RestRequestBuilder.<Map<String, List<HIST>>>builder() .withPath("/hist").get() .withResponse(new GenericType<Map<String, List<HIST>>>() { }) .addQueryParam(getFilterParams()) .build(); } ParameterizedHistRequestBuilder withDate(final LocalDate date); @Override RestRequest<Map<String, List<HIST>>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final RestRequest<Map<String, List<HIST>>> request = new HistRequestBuilder() .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/hist"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Map<String, List<HIST>>>() { }); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).isEmpty(); }
BookRequestBuilder extends AbstractMarketDataRequestBuilder<Map<String, Book>, BookRequestBuilder> implements IEXApiRestRequest<Map<String, Book>>, IEXCloudV1RestRequest<Map<String, Book>> { @Override public RestRequest<Map<String, Book>> build() { return RestRequestBuilder.<Map<String, Book>>builder() .withPath("/deep/book").get() .withResponse(new GenericType<Map<String, Book>>() {}) .addQueryParam(getSymbols()) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<Map<String, Book>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<Map<String, Book>> request = new BookRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/deep/book"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Map<String, Book>>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).contains(entry("symbols", symbol)); }
OpHaltStatusRequestBuilder extends AbstractMarketDataRequestBuilder<Map<String, OpHaltStatus>, OpHaltStatusRequestBuilder> implements IEXApiRestRequest<Map<String, OpHaltStatus>>, IEXCloudV1RestRequest<Map<String, OpHaltStatus>> { @Override public RestRequest<Map<String, OpHaltStatus>> build() { return RestRequestBuilder.<Map<String, OpHaltStatus>>builder() .withPath("/deep/op-halt-status").get() .withResponse(new GenericType<Map<String, OpHaltStatus>>() {}) .addQueryParam(getSymbols()) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<Map<String, OpHaltStatus>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<Map<String, OpHaltStatus>> request = new OpHaltStatusRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/deep/op-halt-status"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Map<String, OpHaltStatus>>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).contains(entry("symbols", symbol)); }
TradingStatusRequestBuilder extends AbstractMarketDataRequestBuilder<Map<String, TradingStatus>, TradingStatusRequestBuilder> implements IEXApiRestRequest<Map<String, TradingStatus>>, IEXCloudV1RestRequest<Map<String, TradingStatus>> { @Override public RestRequest<Map<String, TradingStatus>> build() { return RestRequestBuilder.<Map<String, TradingStatus>>builder() .withPath("/deep/trading-status").get() .withResponse(new GenericType<Map<String, TradingStatus>>() {}) .addQueryParam(getSymbols()) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<Map<String, TradingStatus>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<Map<String, TradingStatus>> request = new TradingStatusRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/deep/trading-status"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Map<String, TradingStatus>>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).contains(entry("symbols", symbol)); }
SsrStatusRequestBuilder extends AbstractMarketDataRequestBuilder<Map<String, SsrStatus>, SsrStatusRequestBuilder> implements IEXApiRestRequest<Map<String, SsrStatus>>, IEXCloudV1RestRequest<Map<String, SsrStatus>> { @Override public RestRequest<Map<String, SsrStatus>> build() { return RestRequestBuilder.<Map<String, SsrStatus>>builder() .withPath("/deep/ssr-status").get() .withResponse(new GenericType<Map<String, SsrStatus>>() {}) .addQueryParam(getSymbols()) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<Map<String, SsrStatus>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<Map<String, SsrStatus>> request = new SsrStatusRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/deep/ssr-status"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Map<String, SsrStatus>>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).contains(entry("symbols", symbol)); }
TodayIpos extends Ipos { public LocalDate getLastUpdate() { return lastUpdate; } @JsonCreator TodayIpos( @JsonProperty("rawData") final List<Ipo> rawData, @JsonProperty("viewData") final List<IpoSummary> viewData, @JsonProperty("lastUpdate") final LocalDate lastUpdate); LocalDate getLastUpdate(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }
@Test public void constructor() { final List<Ipo> rawData = Lists.newArrayList(fixture.collections().createCollection(Ipo.class)); final List<IpoSummary> viewData = Lists.newArrayList(fixture.collections().createCollection(IpoSummary.class)); final LocalDate lastUpdated = fixture.create(LocalDate.class); final TodayIpos todayIpos = new TodayIpos(rawData, viewData, lastUpdated); assertThat(todayIpos.getRawData()).isEqualTo(rawData); assertThat(todayIpos.getViewData()).isEqualTo(viewData); assertThat(todayIpos.getLastUpdate()).isEqualTo(lastUpdated); }
SystemStatusRequestBuilder implements IEXCloudV1RestRequest<SystemStatus> { @Override public RestRequest<SystemStatus> build() { return RestRequestBuilder.<SystemStatus>builder() .withPath("/status").get() .withResponse(SystemStatus.class) .build(); } @Override RestRequest<SystemStatus> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final RestRequest<SystemStatus> request = new SystemStatusRequestBuilder() .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/status"); assertThat(request.getResponseType()).isEqualTo(new GenericType<SystemStatus>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).isEmpty(); }
AbstractRequestFilterBuilder implements IRestRequestBuilder<R> { public B withRequestFilter(RequestFilter requestFilter) { this.requestFilter = requestFilter; return (B) this; } B withRequestFilter(RequestFilter requestFilter); }
@Test public void shouldSuccessfullyAddFilterToQueryParameters() { final String column = "symbol"; final RequestFilter requestFilter = new RequestFilterBuilder() .withColumn(column) .build(); final RestRequest<Map<String, Auction>> request = new AuctionRequestBuilder() .withRequestFilter(requestFilter) .build(); assertThat(request.getQueryParams()).contains(entry("filter", column)); }
CeoCompensationRequestBuilder extends AbstractStocksRequestBuilder<CeoCompensation, CeoCompensationRequestBuilder> implements IEXCloudV1RestRequest<CeoCompensation> { @Override public RestRequest<CeoCompensation> build() { return RestRequestBuilder.<CeoCompensation>builder() .withPath("/stock/{symbol}/ceo-compensation") .addPathParam(SYMBOL_PARAM_NAME, getSymbol()).get() .withResponse(CeoCompensation.class) .build(); } @Override RestRequest<CeoCompensation> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<CeoCompensation> request = new CeoCompensationRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/ceo-compensation"); assertThat(request.getResponseType()).isEqualTo(new GenericType<CeoCompensation>() {}); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
CryptoPriceRequestBuilder extends AbstractStocksRequestBuilder<CryptoPrice, CryptoPriceRequestBuilder> implements IEXCloudV1RestRequest<CryptoPrice> { @Override public RestRequest<CryptoPrice> build() { return RestRequestBuilder.<CryptoPrice>builder() .withPath("/crypto/{symbol}/price") .addPathParam(SYMBOL_PARAM_NAME, getSymbol()).get() .withResponse(new GenericType<CryptoPrice>() {}) .build(); } @Override RestRequest<CryptoPrice> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "BTCUSD"; final RestRequest<CryptoPrice> request = new CryptoPriceRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/crypto/{symbol}/price"); assertThat(request.getResponseType()).isEqualTo(new GenericType<CryptoPrice>() {}); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
CryptoBookRequestBuilder extends AbstractStocksRequestBuilder<Book, CryptoBookRequestBuilder> implements IEXCloudV1RestRequest<Book> { @Override public RestRequest<Book> build() { return RestRequestBuilder.<Book>builder() .withPath("/crypto/{symbol}/book") .addPathParam(SYMBOL_PARAM_NAME, getSymbol()).get() .withResponse(new GenericType<Book>() {}) .build(); } @Override RestRequest<Book> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "BTCUSD"; final RestRequest<Book> request = new CryptoBookRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/crypto/{symbol}/book"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Book>() {}); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
CryptoRequestBuilder extends AbstractStocksRequestBuilder<Quote, CryptoRequestBuilder> implements IEXCloudV1RestRequest<Quote> { @Override public RestRequest<Quote> build() { return RestRequestBuilder.<Quote>builder() .withPath("/crypto/{symbol}/quote") .addPathParam(SYMBOL_PARAM_NAME, getSymbol()).get() .withResponse(new GenericType<Quote>() {}) .build(); } @Override RestRequest<Quote> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<Quote> request = new CryptoRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/crypto/{symbol}/quote"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Quote>() {}); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
DailySentimentRequestBuilder extends AbstractSentimentRequestBuilder<Sentiment, DailySentimentRequestBuilder> implements IEXCloudV1RestRequest<Sentiment> { @Override public RestRequest<Sentiment> build() { if (date != null) { return requestWithDate(); } else if (sentimentType != null) { return requestWithType(); } return request(); } DailySentimentRequestBuilder(); @Override RestRequest<Sentiment> build(); }
@Test public void shouldSuccessfullyCreateTypeRequest() { final String symbol = "IBM"; final RestRequest<Sentiment> request = new DailySentimentRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/sentiment/{type}"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Sentiment>() {}); assertThat(request.getPathParams()).contains(entry("symbol", symbol), entry("type", "daily")); assertThat(request.getQueryParams()).isEmpty(); } @Test public void shouldSuccessfullyCreateTypeAndDateRequest() { final String symbol = "IBM"; final RestRequest<Sentiment> request = new DailySentimentRequestBuilder() .withDate(LocalDate.of(2019, 5, 11)) .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/sentiment/{type}/{date}"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Sentiment>() {}); assertThat(request.getPathParams()).contains(entry("symbol", symbol), entry("type", "daily"), entry("date", "20190511")); assertThat(request.getQueryParams()).isEmpty(); }
SentimentRequestBuilder extends AbstractSentimentRequestBuilder<List<Sentiment>, SentimentRequestBuilder> implements IEXCloudV1RestRequest<List<Sentiment>> { @Override public RestRequest<List<Sentiment>> build() { if (date != null) { return requestWithDate(); } else if (sentimentType != null) { return requestWithType(); } return request(); } SentimentRequestBuilder withSentimentType(final SentimentType sentimentType); @Override RestRequest<List<Sentiment>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final String symbol = "IBM"; final RestRequest<List<Sentiment>> request = new SentimentRequestBuilder() .withSymbol(symbol) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stock/{symbol}/sentiment"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<Sentiment>>() {}); assertThat(request.getPathParams()).containsExactly(entry("symbol", symbol)); assertThat(request.getQueryParams()).isEmpty(); }
MarketRequestBuilder extends AbstractRequestFilterBuilder<List<MarketVolume>, MarketRequestBuilder> implements IEXApiRestRequest<List<MarketVolume>>, IEXCloudV1RestRequest<List<MarketVolume>> { @Override public RestRequest<List<MarketVolume>> build() { return RestRequestBuilder.<List<MarketVolume>>builder() .withPath("/market").get() .withResponse(new GenericType<List<MarketVolume>>() {}) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<List<MarketVolume>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final RestRequest<List<MarketVolume>> request = new MarketRequestBuilder().build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/market"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<MarketVolume>>() {}); assertThat(request.getQueryParams()).isEmpty(); }
Logo implements Serializable { public String getUrl() { return url; } @JsonCreator Logo(@JsonProperty("url") final String url); String getUrl(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void constructor() { final String url = fixture.create(String.class); final Logo logo = new Logo(url); assertThat(logo.getUrl()).isEqualTo(url); }
RecordStatsRequestBuilder extends AbstractRequestFilterBuilder<RecordsStats, RecordStatsRequestBuilder> implements IEXApiRestRequest<RecordsStats>, IEXCloudV1RestRequest<RecordsStats> { @Override public RestRequest<RecordsStats> build() { return RestRequestBuilder.<RecordsStats>builder() .withPath("/stats/records").get() .withResponse(RecordsStats.class) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<RecordsStats> build(); }
@Test public void shouldSuccessfullyCreateRequestWithYearMonthDate() { final RestRequest<RecordsStats> request = new RecordStatsRequestBuilder().build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stats/records"); assertThat(request.getResponseType()).isEqualTo(new GenericType<RecordsStats>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).isEmpty(); }
RecentStatsRequestBuilder extends AbstractRequestFilterBuilder<List<RecentStats>, RecentStatsRequestBuilder> implements IEXApiRestRequest<List<RecentStats>>, IEXCloudV1RestRequest<List<RecentStats>> { @Override public RestRequest<List<RecentStats>> build() { return RestRequestBuilder.<List<RecentStats>>builder() .withPath("/stats/recent").get() .withResponse(new GenericType<List<RecentStats>>() { }) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<List<RecentStats>> build(); }
@Test public void shouldSuccessfullyCreateRequestWithYearMonthDate() { final RestRequest<List<RecentStats>> request = new RecentStatsRequestBuilder().build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stats/recent"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<RecentStats>>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).isEmpty(); }
IntradayStatsRequestBuilder extends AbstractRequestFilterBuilder<IntradayStats, HistoricalStatsRequestBuilder> implements IEXApiRestRequest<IntradayStats>, IEXCloudV1RestRequest<IntradayStats> { @Override public RestRequest<IntradayStats> build() { return RestRequestBuilder.<IntradayStats>builder() .withPath("/stats/intraday").get() .withResponse(IntradayStats.class) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<IntradayStats> build(); }
@Test public void shouldSuccessfullyCreateRequestWithYearMonthDate() { final RestRequest<IntradayStats> request = new IntradayStatsRequestBuilder().build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/stats/intraday"); assertThat(request.getResponseType()).isEqualTo(new GenericType<IntradayStats>() {}); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).isEmpty(); }
IEXNextDayExDateRequestBuilder extends AbstractDailyListRequestBuilder<List<IEXNextDayExDate>, IEXNextDayExDateRequestBuilder> implements IEXApiRestRequest<List<IEXNextDayExDate>> { @Override public RestRequest<List<IEXNextDayExDate>> build() { return RestRequestBuilder.<List<IEXNextDayExDate>>builder() .withPath("/ref-data/daily-list/next-day-ex-date/{date}") .addPathParam("date", getPeriod()).get() .withResponse(new GenericType<List<IEXNextDayExDate>>() { }) .build(); } @Override RestRequest<List<IEXNextDayExDate>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final LocalDate date = LocalDate.of(2017, 5, 5); final RestRequest<List<IEXNextDayExDate>> request = new IEXNextDayExDateRequestBuilder() .withDate(date) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/ref-data/daily-list/next-day-ex-date/{date}"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<IEXNextDayExDate>>() {}); assertThat(request.getPathParams()).contains(entry("date", "20170505")); assertThat(request.getQueryParams()).isEmpty(); }
SymbolsRequestBuilder extends AbstractRequestFilterBuilder<List<ExchangeSymbol>, SymbolsRequestBuilder> implements IEXApiRestRequest<List<ExchangeSymbol>> { @Override public RestRequest<List<ExchangeSymbol>> build() { return RestRequestBuilder.<List<ExchangeSymbol>>builder() .withPath("/ref-data/symbols").get() .withResponse(new GenericType<List<ExchangeSymbol>>() { }) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<List<ExchangeSymbol>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final RestRequest<List<ExchangeSymbol>> request = new SymbolsRequestBuilder().build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/ref-data/symbols"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<ExchangeSymbol>>() {}); assertThat(request.getQueryParams()).isEmpty(); }
IEXDividendsRequestBuilder extends AbstractDailyListRequestBuilder<List<IEXDividends>, IEXDividendsRequestBuilder> implements IEXApiRestRequest<List<IEXDividends>> { @Override public RestRequest<List<IEXDividends>> build() { return RestRequestBuilder.<List<IEXDividends>>builder() .withPath("/ref-data/daily-list/dividends/{date}") .addPathParam("date", getPeriod()).get() .withResponse(new GenericType<List<IEXDividends>>() { }) .build(); } @Override RestRequest<List<IEXDividends>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final LocalDate date = LocalDate.of(2017, 5, 5); final RestRequest<List<IEXDividends>> request = new IEXDividendsRequestBuilder() .withDate(date) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/ref-data/daily-list/dividends/{date}"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<IEXDividends>>() {}); assertThat(request.getPathParams()).contains(entry("date", "20170505")); assertThat(request.getQueryParams()).isEmpty(); }
IEXSymbolDirectoryRequestBuilder extends AbstractDailyListRequestBuilder<List<IEXSymbolDirectory>, IEXSymbolDirectoryRequestBuilder> implements IEXApiRestRequest<List<IEXSymbolDirectory>> { @Override public RestRequest<List<IEXSymbolDirectory>> build() { return RestRequestBuilder.<List<IEXSymbolDirectory>>builder() .withPath("/ref-data/daily-list/symbol-directory/{date}") .addPathParam("date", getPeriod()).get() .withResponse(new GenericType<List<IEXSymbolDirectory>>() { }) .build(); } @Override RestRequest<List<IEXSymbolDirectory>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final LocalDate date = LocalDate.of(2017, 5, 5); final RestRequest<List<IEXSymbolDirectory>> request = new IEXSymbolDirectoryRequestBuilder() .withDate(date) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/ref-data/daily-list/symbol-directory/{date}"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<IEXSymbolDirectory>>() {}); assertThat(request.getPathParams()).contains(entry("date", "20170505")); assertThat(request.getQueryParams()).isEmpty(); }
IEXCorporateActionsRequestBuilder extends AbstractDailyListRequestBuilder<List<IEXCorporateActions>, IEXCorporateActionsRequestBuilder> implements IEXApiRestRequest<List<IEXCorporateActions>> { @Override public RestRequest<List<IEXCorporateActions>> build() { return RestRequestBuilder.<List<IEXCorporateActions>>builder() .withPath("/ref-data/daily-list/corporate-actions/{date}") .addPathParam("date", getPeriod()).get() .withResponse(new GenericType<List<IEXCorporateActions>>() { }) .build(); } @Override RestRequest<List<IEXCorporateActions>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final LocalDate date = LocalDate.of(2017, 5, 5); final RestRequest<List<IEXCorporateActions>> request = new IEXCorporateActionsRequestBuilder() .withDate(date) .build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/ref-data/daily-list/corporate-actions/{date}"); assertThat(request.getResponseType()).isEqualTo(new GenericType<List<IEXCorporateActions>>() {}); assertThat(request.getPathParams()).contains(entry("date", "20170505")); assertThat(request.getQueryParams()).isEmpty(); }
AbstractDailyListRequestBuilder implements IRestRequestBuilder<R> { String getPeriod() { return sample ? "sample" : date == null ? "" : IEX_DATE_FORMATTER.format(date); } B withDate(final LocalDate date); B withSample(); }
@Test public void shouldReturnEmptyString() { final IEXCorporateActionsRequestBuilder requestBuilder = new IEXCorporateActionsRequestBuilder(); final String period = requestBuilder.getPeriod(); assertThat(period).isEmpty(); }
OptionsSymbolsRequestBuilder extends AbstractRequestFilterBuilder<Map<String, List<String>>, OptionsSymbolsRequestBuilder> implements IEXCloudV1RestRequest<Map<String, List<String>>> { @Override public RestRequest<Map<String, List<String>>> build() { return RestRequestBuilder.<Map<String, List<String>>>builder() .withPath("/ref-data/options/symbols").get() .withResponse(new GenericType<Map<String, List<String>>>() { }) .addQueryParam(getFilterParams()) .build(); } @Override RestRequest<Map<String, List<String>>> build(); }
@Test public void shouldSuccessfullyCreateRequest() { final RestRequest<Map<String, List<String>>> request = new OptionsSymbolsRequestBuilder().build(); assertThat(request.getMethodType()).isEqualTo(MethodType.GET); assertThat(request.getPath()).isEqualTo("/ref-data/options/symbols"); assertThat(request.getResponseType()).isEqualTo(new GenericType<Map<String, List<String>>>() { }); assertThat(request.getPathParams()).isEmpty(); assertThat(request.getQueryParams()).isEmpty(); }
FieldMetadata implements Serializable { public String getType() { return type; } @JsonCreator FieldMetadata( @JsonProperty("type") final String type); String getType(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); }
@Test public void constructor() { final String type = fixture.create(String.class); final FieldMetadata fieldMetadata = new FieldMetadata(type); assertThat(fieldMetadata.getType()).isEqualTo(type); }
DoubleGenerator extends RangeGenerator<Double> { public static DoubleGenerator getGridDoubleGenerator(Double start, Double end) { return new DoubleGenerator(start, end, DoubleGenerator::gridGen); } private DoubleGenerator(Double start, Double end, BiFunction<DoubleGenerator, Integer, List<Double>> function); @Override List<Double> expend(int size); static DoubleGenerator getGridDoubleGenerator(Double start, Double end); static DoubleGenerator getUniformDoubleGenerator(Double start, Double end); }
@Test public void getGridDoubleGenerator() { DoubleGenerator dg = DoubleGenerator.getGridDoubleGenerator(0.0, 1.0); double[] expected = {0.0,0.2,0.4,0.6,0.8}; Assert.assertArrayEquals(expected, TestUtils.toArray(dg.expend(5)), 0.001); }
DoubleGenerator extends RangeGenerator<Double> { public static DoubleGenerator getUniformDoubleGenerator(Double start, Double end) { return new DoubleGenerator(start, end, DoubleGenerator::genUniform); } private DoubleGenerator(Double start, Double end, BiFunction<DoubleGenerator, Integer, List<Double>> function); @Override List<Double> expend(int size); static DoubleGenerator getGridDoubleGenerator(Double start, Double end); static DoubleGenerator getUniformDoubleGenerator(Double start, Double end); }
@Test public void getUniformDoubleGenerator() { DoubleGenerator dg = DoubleGenerator.getUniformDoubleGenerator(0.0, 1.0); String joined = Joiner.on(",").join(dg.expend(5)); System.out.println(joined); }
Config implements Runnable { static Config getConfig(String[] args) { Config config = new Config(); CommandLine.run(config, System.err, args); return config; } @Override void run(); }
@Test public void testCommand() { String[] args = {"","train","task","tt"}; Config config = Config.getConfig(args); Assert.assertEquals(config.isTrain, false); Assert.assertEquals(config.task, "tt"); }
User { public boolean isReady() { return getStatus() == Status.READY; } User(); User(long id, String email, String nickname); long getId(); void setId(long id); String getEmail(); void setEmail(String email); String getPassword(); void setPassword(String password); String getNickname(); void setNickname(String nickname); Status getStatus(); void setStatus(Status status); void gameStart(); void ready(); long getEnteredRoomId(); void setEnteredRoomId(long enteredRoomId); boolean matchPassword(User user); boolean isAbleToEnter(long id); @JsonIgnore boolean isLobby(); boolean isSameUser(String nickname); void enterLobby(); void enterRoom(long id); @Override String toString(); boolean isReady(); void toggleReady(); }
@Test public void isReady() { User user = new User(); user.enterRoom(1); assertEquals(false, user.isReady()); }
UserClass implements Serializable { public void setPassword(String password) throws UserException { int MIN_PASSWORD_LENGTH = 6; int MAX_PASSWORD_LENGTH = 16; if((password != null && !password.isEmpty()) && (password.length() < MIN_PASSWORD_LENGTH || password.length() > MAX_PASSWORD_LENGTH)){ throw new UserException("A senha deve ter entre 6 e 16 caracteres"); }else if(password == null || password.isEmpty()){ throw new UserException("Preencha todos os campos!"); }else{ this.password = password; } } UserClass(); UserClass(String className, String institution, float cutOff, String password, float addition, Integer sizeGroups); String getClassName(); void setClassName(String className); int getSizeGroups(); void setSizeGroups(int sizeGroups); String getInstitution(); void setInstitution(String institution); String getPassword(); void setPassword(String password); float getAddition(); void setAddition(float addition); float getCutOff(); void setCutOff(float cutOff); }
@Test public void UserClass_Password(){ boolean isValid = false; UserClass userClass = new UserClass(); try { isValid = true; userClass.setPassword("nome"); } catch (UserException e) { isValid = false; e.printStackTrace(); } assertFalse(isValid); }
About { public int getShowImage(int position){ switch(position){ case 0: return R.drawable.trezentos_icon; case 1: return R.drawable.tedx; case 2: return R.drawable.about_youtube; case 3: return R.drawable.about_youtube; case 4: return R.drawable.documents; case 5: return R.drawable.about_record; default: return R.drawable.about_unb_tv; } } About(); About(String title, String subTitle); void setTitle(String title); String getTitle(); void setSubTitle(String subTitle); String getSubTitle(); int getShowImage(int position); }
@Test public void shouldValidateAboutImage(){ About about = new About(); assertEquals(R.drawable.trezentos_icon, about.getShowImage(0)); assertEquals(R.drawable.tedx, about.getShowImage(1)); assertEquals(R.drawable.about_youtube, about.getShowImage(2)); assertEquals(R.drawable.about_youtube, about.getShowImage(3)); assertEquals(R.drawable.documents, about.getShowImage(4)); assertEquals(R.drawable.about_record, about.getShowImage(5)); assertEquals(R.drawable.about_unb_tv, about.getShowImage(6)); }
Student extends UserAccount { @Override public String toString(){ return "Aluno"; } Student(); @Override String toString(); String getStudentEmail(); void setStudentEmail(String studentEmail); Double getFirstGrade(); void setFirstGrade(Double firstGrade); Double getSecondGrade(); void setSecondGrade(Double secondGrade); }
@Test public void shouldValidateToString(){ Student student = new Student(); assertEquals("Aluno", student.toString()); }
ScriptExtractor extends DefaultObjectPipe<Reader, ObjectReceiver<String>> { @Override public void process(final Reader reader) { try { Document document = Jsoup.parse(IOUtils.toString(reader)); Element firstScript = document.select("script").first(); getReceiver().process(firstScript.data()); } catch (IOException e) { e.printStackTrace(); } } @Override void process(final Reader reader); }
@Test public void testShouldProcessRecordsFollowedbySeparator() { scriptExtractor.process(IN); verify(receiver).process(OUT); verifyNoMoreInteractions(receiver); }
Label { @Override public String toString() { return buffer.stringAt(0, RECORD_LABEL_LENGTH, Iso646Constants.CHARSET); } Label(final Iso646ByteBuffer buffer); @Override String toString(); }
@Test public void toString_shouldReturnRecordLabel() { assertEquals(RECORD_LABEL, label.toString()); }
RecordFormat { public static Builder create() { return new Builder(); } RecordFormat(final int indicatorLength, final int identifierLength, final int fieldLengthLength, final int fieldStartLength, final int implDefinedPartLength); RecordFormat(final RecordFormat source); static Builder create(); static Builder createFrom(final RecordFormat source); int getIndicatorLength(); int getIdentifierLength(); int getFieldLengthLength(); int getFieldStartLength(); int getImplDefinedPartLength(); @Override boolean equals(final Object obj); @Override int hashCode(); @Override String toString(); final int TAG_LENGTH; final int IMPL_CODES_LENGTH; final int SYSTEM_CHARS_LENGTH; }
@Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfIndicatorLengthLessThanZero() { RecordFormat.create().withIndicatorLength(-1); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfIndicatorLengthIsGreaterThanNine() { RecordFormat.create().withIndicatorLength(10); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfIdentifierLengthLessThanZero() { RecordFormat.create().withIdentifierLength(-1); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfIdentifierLengthIsGreaterThanNine() { RecordFormat.create().withIdentifierLength(10); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfFieldStartLengthLessThanOne() { RecordFormat.create().withFieldStartLength(0); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfFieldStartLengthIsGreaterThanNine() { RecordFormat.create().withFieldStartLength(10); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfFieldLengthLengthLessThanOne() { RecordFormat.create().withFieldLengthLength(0); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfFieldLengthLengthIsGreaterThanNine() { RecordFormat.create().withFieldLengthLength(10); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfImplDefinedPartLengthLessThanZero() { RecordFormat.create().withImplDefinedPartLength(-1); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfImplDefinedPartLengthIsGreaterThanNine() { RecordFormat.create().withImplDefinedPartLength(10); }
Marc21Decoder extends DefaultObjectPipe<String, StreamReceiver> { @Override public void process(final String obj) { if (obj.isEmpty()) { return; } final Record record = new Record(obj.getBytes(Marc21Constants.MARC21_CHARSET)); record.setCharset(Marc21Constants.MARC21_CHARSET); requireMarc21RecordFormat(record.getRecordFormat()); requireUTF8Encoding(record); getReceiver().startRecord(tryGetRecordId(record)); emitLeader(record); record.processFields(fieldHandler); getReceiver().endRecord(); } void setIgnoreMissingId(final boolean ignoreMissingId); boolean getIgnoreMissingId(); void setEmitLeaderAsWhole(final boolean emitLeaderAsWhole); boolean getEmitLeaderAsWhole(); @Override void process(final String obj); }
@Test(expected = FormatException.class) public void shouldThrowFormatExceptionIfRecordIsTooShort() { marc21Decoder.process("00005"); } @Test public void shouldProcessMarc21Record() { marc21Decoder.process(RECORD); final InOrder ordered = inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); ordered.verify(receiver).startEntity("leader"); ordered.verify(receiver).literal("status", "n"); ordered.verify(receiver).literal("type", "o"); ordered.verify(receiver).literal("bibliographicLevel", "a"); ordered.verify(receiver).literal("typeOfControl", " "); ordered.verify(receiver).literal("characterCodingScheme", "a"); ordered.verify(receiver).literal("encodingLevel", "z"); ordered.verify(receiver).literal("catalogingForm", "u"); ordered.verify(receiver).literal("multipartLevel", " "); ordered.verify(receiver).endEntity(); ordered.verify(receiver).literal("001", RECORD_ID); ordered.verify(receiver).literal("002", CONTROLFIELD_VALUE); ordered.verify(receiver).startEntity("100AB"); ordered.verify(receiver).literal("1", "value1"); ordered.verify(receiver).endEntity(); ordered.verify(receiver).startEntity("200CD"); ordered.verify(receiver).literal("2", "value2"); ordered.verify(receiver).literal("3", "value3"); ordered.verify(receiver).endEntity(); ordered.verify(receiver).endRecord(); } @Test public void shouldIgnoreEmptyRecords() { marc21Decoder.process(""); verifyZeroInteractions(receiver); } @Test(expected = FormatException.class) public void shouldThrowFormatExceptionIfRecordIsNotMarc21() { marc21Decoder.process("00026RIMPL1100024SYS3330" + FIELD_SEPARATOR + RECORD_SEPARATOR); }
RecordBuilder { public byte[] build() { requireNotInDataField(); final int baseAddress = RECORD_LABEL_LENGTH + directory.length(); final int recordLength = baseAddress + fields.length(); label.setBaseAddress(baseAddress); label.setRecordLength(recordLength); final byte[] recordBuffer = new byte[recordLength]; label.copyToBuffer(recordBuffer); directory.copyToBuffer(recordBuffer, RECORD_LABEL_LENGTH); fields.copyToBuffer(recordBuffer, baseAddress); return recordBuffer; } RecordBuilder(final RecordFormat recordFormat); void setCharset(final Charset charset); Charset getCharset(); void setRecordStatus(final char recordStatus); void setImplCodes(final char[] implCodes); void setImplCode(final int index, final char implCode); void setSystemChars(final char[] systemChars); void setSystemChar(final int index, final char systemChar); void setReservedChar(final char reservedChar); void appendIdentifierField(final String value); void appendIdentifierField(final char[] implDefinedPart, final String value); void appendReferenceField(final char[] tag, final String value); void appendReferenceField(final char[] tag, final char[] implDefinedPart, final String value); void startDataField(final char[] tag); void startDataField(final char[] tag, final char[] indicators); void startDataField(final char[] tag, final char[] indicators, final char[] implDefinedPart); void endDataField(); void appendSubfield(final String value); void appendSubfield(final char[] identifier, final String value); byte[] build(); void reset(); @Override String toString(); }
@Test public void shouldWriteRecordFormatToRecordLabel() { format = RecordFormat.create() .withIndicatorLength(2) .withIdentifierLength(3) .withFieldStartLength(4) .withFieldLengthLength(5) .withImplDefinedPartLength(6) .build(); final RecordBuilder builder = new RecordBuilder(format); final byte[] record = builder.build(); assertEquals("23", asString(record, 10, 12)); assertEquals("546", asString(record, 20, 23)); } @Test public void shouldWriteSpaceIfRecordStatusNotSet() { final byte[] record = builder.build(); assertEquals(0x20, record[5]); } @Test public void shouldWriteSpacesIfImplCodesNotSet() { final byte[] record = builder.build(); assertEquals(0x20, record[6]); assertEquals(0x20, record[7]); assertEquals(0x20, record[8]); assertEquals(0x20, record[9]); } @Test public void shouldWriteSpacesIfSystemCharsNotSet() { final byte[] record = builder.build(); assertEquals(0x20, record[17]); assertEquals(0x20, record[18]); assertEquals(0x20, record[19]); } @Test public void shouldWriteSpaceIfReservedCharNotSet() { final byte[] record = builder.build(); assertEquals(0x20, record[23]); } @Test public void shouldEndWithRecordSeparator() { final byte[] record = builder.build(); assertEquals('\u001d', record[record.length - 1]); }
RecordBuilder { public void setRecordStatus(final char recordStatus) { require7BitAscii(recordStatus); label.setRecordStatus(recordStatus); } RecordBuilder(final RecordFormat recordFormat); void setCharset(final Charset charset); Charset getCharset(); void setRecordStatus(final char recordStatus); void setImplCodes(final char[] implCodes); void setImplCode(final int index, final char implCode); void setSystemChars(final char[] systemChars); void setSystemChar(final int index, final char systemChar); void setReservedChar(final char reservedChar); void appendIdentifierField(final String value); void appendIdentifierField(final char[] implDefinedPart, final String value); void appendReferenceField(final char[] tag, final String value); void appendReferenceField(final char[] tag, final char[] implDefinedPart, final String value); void startDataField(final char[] tag); void startDataField(final char[] tag, final char[] indicators); void startDataField(final char[] tag, final char[] indicators, final char[] implDefinedPart); void endDataField(); void appendSubfield(final String value); void appendSubfield(final char[] identifier, final String value); byte[] build(); void reset(); @Override String toString(); }
@Test(expected=IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfRecordStatusIsNot7BitAscii() { builder.setRecordStatus('\u00df'); } @Test(expected=IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfRecordStatusIsInformationSeparator() { builder.setRecordStatus('\u001e'); }
RecordBuilder { public void setImplCodes(final char[] implCodes) { Require.notNull(implCodes); Require.that(implCodes.length == IMPL_CODES_LENGTH); require7BitAscii(implCodes); label.setImplCodes(implCodes); } RecordBuilder(final RecordFormat recordFormat); void setCharset(final Charset charset); Charset getCharset(); void setRecordStatus(final char recordStatus); void setImplCodes(final char[] implCodes); void setImplCode(final int index, final char implCode); void setSystemChars(final char[] systemChars); void setSystemChar(final int index, final char systemChar); void setReservedChar(final char reservedChar); void appendIdentifierField(final String value); void appendIdentifierField(final char[] implDefinedPart, final String value); void appendReferenceField(final char[] tag, final String value); void appendReferenceField(final char[] tag, final char[] implDefinedPart, final String value); void startDataField(final char[] tag); void startDataField(final char[] tag, final char[] indicators); void startDataField(final char[] tag, final char[] indicators, final char[] implDefinedPart); void endDataField(); void appendSubfield(final String value); void appendSubfield(final char[] identifier, final String value); byte[] build(); void reset(); @Override String toString(); }
@Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionIfLengthOfImplCodesIsLessThanFour() { builder.setImplCodes(asChars("123")); } @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionIfLengthOfImplCodesIsGreaterThanFour() { builder.setImplCodes(asChars("12345")); } @Test(expected=IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfImplCodesAreNot7BitAscii() { builder.setImplCodes(asChars("12\u00df4")); } @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionIfImplCodesIsNull() { builder.setImplCodes(null); }
MarcXmlEncoder extends DefaultStreamPipe<ObjectReceiver<String>> { public void omitXmlDeclaration(boolean omitXmlDeclaration) { this.omitXmlDeclaration = omitXmlDeclaration; } MarcXmlEncoder(); void omitXmlDeclaration(boolean omitXmlDeclaration); void setXmlVersion(String xmlVersion); void setXmlEncoding(String xmlEncoding); void setFormatted(boolean formatted); @Override void startRecord(final String identifier); @Override void endRecord(); @Override void startEntity(final String name); @Override void endEntity(); @Override void literal(final String name, final String value); }
@Test public void doNotOmitXmlDeclaration() { encoder.omitXmlDeclaration(false); addOneRecord(encoder); encoder.closeStream(); String actual = resultCollector.toString(); assertTrue(actual.startsWith(XML_DECLARATION)); } @Test public void omitXmlDeclaration() { encoder.omitXmlDeclaration(true); addOneRecord(encoder); encoder.closeStream(); String actual = resultCollector.toString(); assertTrue(actual.startsWith("<marc:collection")); assertTrue(actual.endsWith(XML_MARC_COLLECTION_END_TAG)); }
RecordBuilder { public void setSystemChars(final char[] systemChars) { Require.notNull(systemChars); Require.that(systemChars.length == SYSTEM_CHARS_LENGTH); require7BitAscii(systemChars); label.setSystemChars(systemChars); } RecordBuilder(final RecordFormat recordFormat); void setCharset(final Charset charset); Charset getCharset(); void setRecordStatus(final char recordStatus); void setImplCodes(final char[] implCodes); void setImplCode(final int index, final char implCode); void setSystemChars(final char[] systemChars); void setSystemChar(final int index, final char systemChar); void setReservedChar(final char reservedChar); void appendIdentifierField(final String value); void appendIdentifierField(final char[] implDefinedPart, final String value); void appendReferenceField(final char[] tag, final String value); void appendReferenceField(final char[] tag, final char[] implDefinedPart, final String value); void startDataField(final char[] tag); void startDataField(final char[] tag, final char[] indicators); void startDataField(final char[] tag, final char[] indicators, final char[] implDefinedPart); void endDataField(); void appendSubfield(final String value); void appendSubfield(final char[] identifier, final String value); byte[] build(); void reset(); @Override String toString(); }
@Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionIfLengthOfSystemCharsIsLessThanThree() { builder.setSystemChars(asChars("12")); } @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionIfLengthOfSystemCharsIsGreaterThanThree() { builder.setSystemChars(asChars("1234")); } @Test(expected=IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfSystemCharsAreNot7BitAscii() { builder.setSystemChars(asChars("1\u00df3")); } @Test(expected=IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfSystemCharIsInformationSeparator() { builder.setSystemChars(asChars("1\u001e3")); } @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionIfSystemCharsIsNull() { builder.setSystemChars(null); }
RecordBuilder { public void setSystemChar(final int index, final char systemChar) { Require.that(0 <= index && index < SYSTEM_CHARS_LENGTH); require7BitAscii(systemChar); label.setSystemChar(index, systemChar); } RecordBuilder(final RecordFormat recordFormat); void setCharset(final Charset charset); Charset getCharset(); void setRecordStatus(final char recordStatus); void setImplCodes(final char[] implCodes); void setImplCode(final int index, final char implCode); void setSystemChars(final char[] systemChars); void setSystemChar(final int index, final char systemChar); void setReservedChar(final char reservedChar); void appendIdentifierField(final String value); void appendIdentifierField(final char[] implDefinedPart, final String value); void appendReferenceField(final char[] tag, final String value); void appendReferenceField(final char[] tag, final char[] implDefinedPart, final String value); void startDataField(final char[] tag); void startDataField(final char[] tag, final char[] indicators); void startDataField(final char[] tag, final char[] indicators, final char[] implDefinedPart); void endDataField(); void appendSubfield(final String value); void appendSubfield(final char[] identifier, final String value); byte[] build(); void reset(); @Override String toString(); }
@Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionIfSystemCharIndexGreaterThan2() { builder.setSystemChar(3, '1'); }
RecordBuilder { public void setReservedChar(final char reservedChar) { require7BitAscii(reservedChar); label.setReservedChar(reservedChar); } RecordBuilder(final RecordFormat recordFormat); void setCharset(final Charset charset); Charset getCharset(); void setRecordStatus(final char recordStatus); void setImplCodes(final char[] implCodes); void setImplCode(final int index, final char implCode); void setSystemChars(final char[] systemChars); void setSystemChar(final int index, final char systemChar); void setReservedChar(final char reservedChar); void appendIdentifierField(final String value); void appendIdentifierField(final char[] implDefinedPart, final String value); void appendReferenceField(final char[] tag, final String value); void appendReferenceField(final char[] tag, final char[] implDefinedPart, final String value); void startDataField(final char[] tag); void startDataField(final char[] tag, final char[] indicators); void startDataField(final char[] tag, final char[] indicators, final char[] implDefinedPart); void endDataField(); void appendSubfield(final String value); void appendSubfield(final char[] identifier, final String value); byte[] build(); void reset(); @Override String toString(); }
@Test(expected=IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfReservedCharIsNot7BitAscii() { builder.setReservedChar('\u00df'); } @Test(expected=IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfReservedCharIsInformationSeparator() { builder.setReservedChar('\u001d'); }
RecordBuilder { public void appendReferenceField(final char[] tag, final String value) { appendReferenceField(tag, defaultImplDefinedPart, value); } RecordBuilder(final RecordFormat recordFormat); void setCharset(final Charset charset); Charset getCharset(); void setRecordStatus(final char recordStatus); void setImplCodes(final char[] implCodes); void setImplCode(final int index, final char implCode); void setSystemChars(final char[] systemChars); void setSystemChar(final int index, final char systemChar); void setReservedChar(final char reservedChar); void appendIdentifierField(final String value); void appendIdentifierField(final char[] implDefinedPart, final String value); void appendReferenceField(final char[] tag, final String value); void appendReferenceField(final char[] tag, final char[] implDefinedPart, final String value); void startDataField(final char[] tag); void startDataField(final char[] tag, final char[] indicators); void startDataField(final char[] tag, final char[] indicators, final char[] implDefinedPart); void endDataField(); void appendSubfield(final String value); void appendSubfield(final char[] identifier, final String value); byte[] build(); void reset(); @Override String toString(); }
@Test(expected = FormatException.class) public void shouldThrowFormatExceptionIfStartOfReferenceFieldIsNotInAddressRange() { final String longValue = StringUtil.repeatChars('A', 1000); builder.appendReferenceField(asChars("002"), asChars("IM"), longValue); builder.appendReferenceField(asChars("003"), asChars("IM"), "would not fit"); } @Test(expected = FormatException.class) public void shouldThrowFormatExceptionIfStartOfLastPartOfReferenceFieldIsNotInAddressRange() { final String tooLongValue = StringUtil.repeatChars('A', 1100); builder.appendReferenceField(asChars("002"), asChars("IM"), tooLongValue); } @Test(expected = FormatException.class) public void shouldThrowFormatExceptionIfReferenceFieldTagLengthIsNotThree() { builder.appendReferenceField(asChars("0020"), asChars("IM"), "Value"); } @Test(expected = FormatException.class) public void shouldThrowFormatExceptionIfTagDoesNotStartWithTwoZeros() { builder.appendReferenceField(asChars("012"), asChars("IM"), "Value"); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfReferenceFieldTagIsNull() { builder.appendReferenceField(null, asChars("IM"), "Value"); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfReferenceFieldImplDefinedPartLengthDoesNotMatchFormat() { builder.appendReferenceField(asChars("002"), asChars("IMP"), "Value"); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfReferenceFieldImplDefinedPartIsNot7BitAscii() { builder.appendReferenceField(asChars("002"), asChars("I\u00df"), "Value"); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfReferenceFieldImplDefinedPartIsInformationSeparator() { builder.appendReferenceField(asChars("002"), asChars("I\u001d"), "Value"); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfReferenceFieldImplDefinedPartIsNull() { builder.appendReferenceField(asChars("002"), null, "value"); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfReferenceFieldValueIsNull() { builder.appendReferenceField(asChars("002"), asChars("IM"), null); }
MarcXmlEncoder extends DefaultStreamPipe<ObjectReceiver<String>> { public void setXmlVersion(String xmlVersion) { this.xmlVersion = xmlVersion; } MarcXmlEncoder(); void omitXmlDeclaration(boolean omitXmlDeclaration); void setXmlVersion(String xmlVersion); void setXmlEncoding(String xmlEncoding); void setFormatted(boolean formatted); @Override void startRecord(final String identifier); @Override void endRecord(); @Override void startEntity(final String name); @Override void endEntity(); @Override void literal(final String name, final String value); }
@Test public void setXmlVersion() { encoder.omitXmlDeclaration(false); encoder.setXmlVersion("1.1"); addOneRecord(encoder); encoder.closeStream(); String actual = resultCollector.toString(); assertTrue(actual.startsWith(XML_1_DECLARATION)); }
RecordBuilder { public void startDataField(final char[] tag) { startDataField(tag, defaultIndicators); } RecordBuilder(final RecordFormat recordFormat); void setCharset(final Charset charset); Charset getCharset(); void setRecordStatus(final char recordStatus); void setImplCodes(final char[] implCodes); void setImplCode(final int index, final char implCode); void setSystemChars(final char[] systemChars); void setSystemChar(final int index, final char systemChar); void setReservedChar(final char reservedChar); void appendIdentifierField(final String value); void appendIdentifierField(final char[] implDefinedPart, final String value); void appendReferenceField(final char[] tag, final String value); void appendReferenceField(final char[] tag, final char[] implDefinedPart, final String value); void startDataField(final char[] tag); void startDataField(final char[] tag, final char[] indicators); void startDataField(final char[] tag, final char[] indicators, final char[] implDefinedPart); void endDataField(); void appendSubfield(final String value); void appendSubfield(final char[] identifier, final String value); byte[] build(); void reset(); @Override String toString(); }
@Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfImplDefinedPartIsNot7BitAscii() { builder.startDataField(asChars("012"), asChars("IN"), asChars("I\u00df")); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfImplDefinedPartIsInformationSeparator() { builder.startDataField(asChars("012"), asChars("IN"), asChars("I\u001f")); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfIndicatorsAreNot7BitAscii() { builder.startDataField(asChars("012"), asChars("I\u00df")); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfIndicatorsIsInformationSeparator() { builder.startDataField(asChars("012"), asChars("I\u001e")); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfDataFieldTagIsNull() { builder.startDataField(null, asChars("IN"), asChars("IM")); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfDataFieldIndicatorsIsNull() { builder.startDataField(asChars("020"), null, asChars("IM")); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfDataFieldImplDefinedPartIsNull() { builder.startDataField(asChars("020"), asChars("IN"), null); } @Test(expected = FormatException.class) public void shouldThrowFormatExceptionIfDataFieldTagLengthIsNotThree() { builder.startDataField(asChars("01"), asChars("IN"), asChars("IM")); } @Test(expected = FormatException.class) public void shouldThrowFormatExceptionIfDataFieldTagStartsWithTwoZeros() { builder.startDataField(asChars("002"), asChars("IN"), asChars("IM")); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfDataFieldImplDefinedPartLengthDoesNotMatchFormat() { builder.startDataField(asChars("020"), asChars("IN"), asChars("IMP")); } @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfIndicatorsLenghtDoesNotMatchformat() { builder.startDataField(asChars("020"), asChars("INS"), asChars("IM")); } @Test(expected = IllegalStateException.class) public void shouldThrowIllegalStateExceptionIfStartAppendFieldIsCalledTwice() { builder.startDataField(asChars("020"), asChars("IN"), asChars("IM")); builder.startDataField(asChars("020"), asChars("IN"), asChars("IM")); }
MarcXmlEncoder extends DefaultStreamPipe<ObjectReceiver<String>> { public void setXmlEncoding(String xmlEncoding) { this.xmlEncoding = xmlEncoding; } MarcXmlEncoder(); void omitXmlDeclaration(boolean omitXmlDeclaration); void setXmlVersion(String xmlVersion); void setXmlEncoding(String xmlEncoding); void setFormatted(boolean formatted); @Override void startRecord(final String identifier); @Override void endRecord(); @Override void startEntity(final String name); @Override void endEntity(); @Override void literal(final String name, final String value); }
@Test public void setXmlEncoding() { encoder.omitXmlDeclaration(false); encoder.setXmlEncoding("UTF-16"); addOneRecord(encoder); encoder.closeStream(); String actual = resultCollector.toString(); assertTrue(actual.startsWith(XML_16_DECLARATION)); }
RecordBuilder { public void appendSubfield(final String value) { requireInDataField(); Require.notNull(value); fields.appendSubfield(defaultIdentifier, value); } RecordBuilder(final RecordFormat recordFormat); void setCharset(final Charset charset); Charset getCharset(); void setRecordStatus(final char recordStatus); void setImplCodes(final char[] implCodes); void setImplCode(final int index, final char implCode); void setSystemChars(final char[] systemChars); void setSystemChar(final int index, final char systemChar); void setReservedChar(final char reservedChar); void appendIdentifierField(final String value); void appendIdentifierField(final char[] implDefinedPart, final String value); void appendReferenceField(final char[] tag, final String value); void appendReferenceField(final char[] tag, final char[] implDefinedPart, final String value); void startDataField(final char[] tag); void startDataField(final char[] tag, final char[] indicators); void startDataField(final char[] tag, final char[] indicators, final char[] implDefinedPart); void endDataField(); void appendSubfield(final String value); void appendSubfield(final char[] identifier, final String value); byte[] build(); void reset(); @Override String toString(); }
@Test(expected = IllegalStateException.class) public void shouldThrowIllegalStateExceptionIfAppendSubfieldIsNotCalledWithinAppendFieldSequence() { builder.appendSubfield(asChars("A"), "Value"); }
RecordBuilder { public void endDataField() { requireInDataField(); final int fieldEnd = fields.endField(); appendState = AppendState.DATA_FIELD; try { directory.addEntries(tag, implDefinedPart, fieldStart, fieldEnd); } catch (final FormatException e) { fields.undoLastField(); throw e; } } RecordBuilder(final RecordFormat recordFormat); void setCharset(final Charset charset); Charset getCharset(); void setRecordStatus(final char recordStatus); void setImplCodes(final char[] implCodes); void setImplCode(final int index, final char implCode); void setSystemChars(final char[] systemChars); void setSystemChar(final int index, final char systemChar); void setReservedChar(final char reservedChar); void appendIdentifierField(final String value); void appendIdentifierField(final char[] implDefinedPart, final String value); void appendReferenceField(final char[] tag, final String value); void appendReferenceField(final char[] tag, final char[] implDefinedPart, final String value); void startDataField(final char[] tag); void startDataField(final char[] tag, final char[] indicators); void startDataField(final char[] tag, final char[] indicators, final char[] implDefinedPart); void endDataField(); void appendSubfield(final String value); void appendSubfield(final char[] identifier, final String value); byte[] build(); void reset(); @Override String toString(); }
@Test(expected = IllegalStateException.class) public void shouldThrowIllegalStateExceptionIfEndAppendFieldIsNotMatchedByStartAppendField() { builder.endDataField(); }
MabDecoder extends DefaultObjectPipe<String, StreamReceiver> { @Override public void process(final String record) { assert !isClosed(); if (record.trim().isEmpty()) { return; } getReceiver().startRecord(extractIdFromRecord(record)); try { getReceiver().literal(LEADER, record.substring(0, HEADER_SIZE)); getReceiver().literal(TYPE, String.valueOf(record.charAt(HEADER_SIZE-1))); final String content = record.substring(HEADER_SIZE); for (final String part : FIELD_PATTERN.split(content)) { if (!part.startsWith(RECORD_END)) { final String fieldName = part.substring(0, FIELD_NAME_SIZE).trim(); final String fieldContent = part.substring(FIELD_NAME_SIZE); final String[] subFields = SUBFIELD_PATTERN.split(fieldContent); if (subFields.length == 1) { getReceiver().literal(fieldName, subFields[0]); } else { getReceiver().startEntity(fieldName); for (int i = 1; i < subFields.length; ++i) { final String name = subFields[i].substring(0, 1); final String value = subFields[i].substring(1); getReceiver().literal(name, value); } getReceiver().endEntity(); } } } } catch (final IndexOutOfBoundsException e) { throw new FormatException("[" + record + "]", e); } getReceiver().endRecord(); } @Override void process(final String record); }
@Test public void shouldParseMabRecord() { mabDecoder.process("00068nM2.01200024 h" + "001 1234\u001E" + "705a\u001FaSubfield 1\u001FbSubfield 2\u001E" + "705b\u001FcSubfield 3\u001FdSubfield 4\u001E" + "\u001D"); final InOrder ordered = inOrder(receiver); ordered.verify(receiver).startRecord("1234"); ordered.verify(receiver).literal("001", "1234"); ordered.verify(receiver).startEntity("705a"); ordered.verify(receiver).literal("a", "Subfield 1"); ordered.verify(receiver).literal("b", "Subfield 2"); ordered.verify(receiver).endEntity(); ordered.verify(receiver).startEntity("705b"); ordered.verify(receiver).literal("c", "Subfield 3"); ordered.verify(receiver).literal("d", "Subfield 4"); ordered.verify(receiver).endEntity(); ordered.verify(receiver).endRecord(); } @Test public void shouldSkipWhitespaceOnlyInput() { mabDecoder.process(" "); mabDecoder.closeStream(); verify(receiver).closeStream(); verifyNoMoreInteractions(receiver); }
Histogram extends DefaultStreamReceiver { @Override public void resetStream() { histogram.clear(); } Histogram(); Histogram(final String countField); Map<String, Integer> getHistogram(); boolean isCountEntities(); void setCountEntities(final boolean countEntities); boolean isCountLiterals(); void setCountLiterals(final boolean countLiterals); String getCountField(); void setCountField(final String countField); @Override void startEntity(final String name); @Override void literal(final String name, final String value); @Override void resetStream(); }
@Test public void testResetStream() { final Histogram histogram = new Histogram(); histogram.setCountEntities(true); assertTrue(histogram.isCountEntities()); assertFalse(histogram.isCountLiterals()); assertNull(histogram.getCountField()); histogram.startRecord(RECORD_ID); histogram.startEntity(ENTITIES[0]); histogram.endEntity(); histogram.endRecord(); final Map<String, Integer> expected = new HashMap<String, Integer>(); expected.put(ENTITIES[0], Integer.valueOf(1)); assertEquals(expected, histogram.getHistogram()); histogram.resetStream(); expected.clear(); assertEquals(expected, histogram.getHistogram()); }
UniformSampler extends DefaultObjectPipe<T, ObjectReceiver<T>> { @Override public void process(final T obj) { assert !isClosed(); assert null!=obj; count += 1; if (sample.size() < sampleSize) { sample.add(obj); } else { final double p = sampleSize / (double)count; if (random.nextDouble() < p) { sample.set(random.nextInt(sampleSize), obj); } } } UniformSampler(final int sampleSize); UniformSampler(final String sampleSize); int getSampleSize(); void setSeed(final long seed); @Override void process(final T obj); }
@Test public void testShouldEmitARandomSubsetOfTheInputObjects() { for(int i = 0; i < setSize; ++i) { sampler.process(Integer.toString(i)); } sampler.closeStream(); final InOrder ordered = inOrder(receiver); for(int i = 0; i < expected.length; ++i) { ordered.verify(receiver).process(expected[i]); } ordered.verify(receiver).closeStream(); }
EntityPathTracker extends DefaultStreamReceiver { public String getCurrentPath() { return currentPath.toString(); } String getCurrentPath(); String getCurrentPathWith(final String literalName); String getCurrentEntityName(); String getEntitySeparator(); void setEntitySeparator(final String entitySeparator); @Override void startRecord(final String identifier); @Override void endRecord(); @Override void startEntity(final String name); @Override void endEntity(); @Override void closeStream(); @Override void resetStream(); static final String DEFAULT_ENTITY_SEPARATOR; }
@Test public void getCurrentPath_shouldReturnEmptyPathIfProcessingHasNotStarted() { assertTrue(pathTracker.getCurrentPath().isEmpty()); }
MarcXmlEncoder extends DefaultStreamPipe<ObjectReceiver<String>> { public void setFormatted(boolean formatted) { this.formatted = formatted; } MarcXmlEncoder(); void omitXmlDeclaration(boolean omitXmlDeclaration); void setXmlVersion(String xmlVersion); void setXmlEncoding(String xmlEncoding); void setFormatted(boolean formatted); @Override void startRecord(final String identifier); @Override void endRecord(); @Override void startEntity(final String name); @Override void endEntity(); @Override void literal(final String name, final String value); }
@Test public void createARecordPrettyPrint() { encoder.setFormatted(true); addOneRecord(encoder); encoder.closeStream(); String expected = XML_DECLARATION + "\n" + XML_ROOT_OPEN + "\n" + "\t<marc:record>\n" + "\t\t<marc:controlfield tag=\"001\">92005291</marc:controlfield>\n" + "\t\t<marc:datafield tag=\"010\" ind1=\" \" ind2=\" \">\n" + "\t\t\t<marc:subfield code=\"a\">92005291</marc:subfield>\n" + "\t\t</marc:datafield>\n" + "\t</marc:record>\n" + XML_MARC_COLLECTION_END_TAG; String actual = resultCollector.toString(); assertEquals(expected, actual); }
EntityPathTracker extends DefaultStreamReceiver { public String getCurrentEntityName() { return entityStack.peek(); } String getCurrentPath(); String getCurrentPathWith(final String literalName); String getCurrentEntityName(); String getEntitySeparator(); void setEntitySeparator(final String entitySeparator); @Override void startRecord(final String identifier); @Override void endRecord(); @Override void startEntity(final String name); @Override void endEntity(); @Override void closeStream(); @Override void resetStream(); static final String DEFAULT_ENTITY_SEPARATOR; }
@Test public void getCurrentEntityName_shouldReturnNullIfProcessingNotStarted() { assertNull(pathTracker.getCurrentEntityName()); }
NullFilter extends ForwardingStreamPipe { @Override public void literal(final String name, final String value) { if (value != null) { getReceiver().literal(name, value); } else if (replacement != null) { getReceiver().literal(name, replacement); } } void setReplacement(final String replacement); String getReplacement(); @Override void literal(final String name, final String value); }
@Test public void shouldForwardAllEvents() { nullFilter.startRecord(RECORD_ID); nullFilter.startEntity(ENTITY_NAME); nullFilter.literal(LITERAL_NAME, LITERAL_VALUE); nullFilter.endEntity(); nullFilter.endRecord(); final InOrder ordered = inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); ordered.verify(receiver).startEntity(ENTITY_NAME); ordered.verify(receiver).literal(LITERAL_NAME, LITERAL_VALUE); ordered.verify(receiver).endEntity(); ordered.verify(receiver).endRecord(); verifyNoMoreInteractions(receiver); } @Test public void shouldDiscardNullValues() { nullFilter.startRecord(RECORD_ID); nullFilter.startEntity(ENTITY_NAME); nullFilter.literal(LITERAL_NAME, LITERAL_VALUE); nullFilter.literal(LITERAL_NAME, null); nullFilter.endEntity(); nullFilter.endRecord(); final InOrder ordered = inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); ordered.verify(receiver).startEntity(ENTITY_NAME); ordered.verify(receiver).literal(LITERAL_NAME, LITERAL_VALUE); ordered.verify(receiver).endEntity(); ordered.verify(receiver).endRecord(); verifyNoMoreInteractions(receiver); }
DuplicateObjectFilter extends DefaultObjectPipe<T, ObjectReceiver<T>> { @Override public void process(final T obj) { if (!obj.equals(lastObj)) { lastObj = obj; getReceiver().process(obj); } } @Override void process(final T obj); }
@Test public void testShouldEliminateDuplicateObjects() { duplicateObjectFilter.process(OBJECT1); duplicateObjectFilter.process(OBJECT1); duplicateObjectFilter.process(OBJECT2); verify(receiver).process(OBJECT1); verify(receiver).process(OBJECT2); verifyNoMoreInteractions(receiver); }
ObjectToLiteral extends DefaultObjectPipe<T, StreamReceiver> { @Override public void process(final T obj) { assert obj!=null; assert !isClosed(); getReceiver().startRecord(""); getReceiver().literal(literalName, obj.toString()); getReceiver().endRecord(); } void setLiteralName(final String literalName); String getLiteralName(); @Override void process(final T obj); static final String DEFAULT_LITERAL_NAME; }
@Test public void testShouldUseObjectAsLiteralValue() { objectToLiteral.process(OBJ_DATA); final InOrder ordered = inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).literal(ObjectToLiteral.DEFAULT_LITERAL_NAME, OBJ_DATA); ordered.verify(receiver).endRecord(); }
ObjectTimer extends TimerBase<ObjectReceiver<T>> implements ObjectPipe<T, ObjectReceiver<T>> { @Override public void process(final T obj) { startMeasurement(); getReceiver().process(obj); stopMeasurement(); } ObjectTimer(); ObjectTimer(final String logPrefix); @Override void process(final T obj); }
@Test public void testShouldMeasureExecutionTime() { objectTimer.process(""); objectTimer.process(""); objectTimer.process(""); objectTimer.process(""); objectTimer.closeStream(); }
FormetaRecordsReader extends DefaultObjectPipe<Reader, ObjectReceiver<String>> { @Override public void process(final Reader reader) { assert !isClosed(); try { boolean readSomething = false; boolean inQuotedText = false; int groupLevel = 0; int size; while ((size = reader.read(buffer)) != -1) { readSomething = true; int offset = 0; for (int i = 0; i < size; ++i) { switch (buffer[i]) { case Formeta.ESCAPE_CHAR: i += 1; break; case Formeta.GROUP_START: if (!inQuotedText) { groupLevel += 1; } break; case Formeta.GROUP_END: if (!inQuotedText) { groupLevel -= 1; } case Formeta.ITEM_SEPARATOR: if (!inQuotedText && groupLevel == 0) { builder.append(buffer, offset, i - offset + 1); offset = i + 1; emitRecord(); } break; case Formeta.QUOT_CHAR: inQuotedText = !inQuotedText; break; } } builder.append(buffer, offset, size - offset); } if (readSomething) { emitRecord(); } } catch (final IOException e) { throw new MetafactureException(e); } } @Override void process(final Reader reader); }
@Test public void shouldProcessSingleRecord() { final StringReader reader = new StringReader(SINGLE_RECORD); formetaRecordsReader.process(reader); verify(receiver).process(SINGLE_RECORD); verifyNoMoreInteractions(receiver); } @Test public void shouldSplitBetweenTopLevelElements() { final String records = RECORD_LITERAL + RECORD_GROUP + RECORD_NESTED_GROUP + RECORD_QUOTED_LITERAL + RECORD_LEFT_BRACE_IN_QUOTES + RECORD_RIGHT_BRACE_IN_QUOTES + RECORD_COLON_IN_QUOTES + RECORD_COMMA_IN_QUOTES + RECORD_ESCAPED_LEFT_BRACE + RECORD_ESCAPED_RIGHT_BRACE + RECORD_ESCAPED_COLON + RECORD_ESCAPED_COMMA + RECORD_ESCAPED_QUOTE; final StringReader reader = new StringReader(records); formetaRecordsReader.process(reader); verify(receiver).process(RECORD_LITERAL); verify(receiver).process(RECORD_GROUP); verify(receiver).process(RECORD_NESTED_GROUP); verify(receiver).process(RECORD_QUOTED_LITERAL); verify(receiver).process(RECORD_LEFT_BRACE_IN_QUOTES); verify(receiver).process(RECORD_RIGHT_BRACE_IN_QUOTES); verify(receiver).process(RECORD_COLON_IN_QUOTES); verify(receiver).process(RECORD_COMMA_IN_QUOTES); verify(receiver).process(RECORD_ESCAPED_LEFT_BRACE); verify(receiver).process(RECORD_ESCAPED_RIGHT_BRACE); verify(receiver).process(RECORD_ESCAPED_COLON); verify(receiver).process(RECORD_ESCAPED_COMMA); verify(receiver).process(RECORD_ESCAPED_QUOTE); verifyNoMoreInteractions(receiver); }
FormetaEncoder extends DefaultStreamPipe<ObjectReceiver<String>> { public void setStyle(final FormatterStyle formatterStyle) { this.style = formatterStyle; formatter = formatterStyle.createFormatter(); } FormatterStyle getStyle(); void setStyle(final FormatterStyle formatterStyle); @Override void startRecord(final String identifier); @Override void endRecord(); @Override void startEntity(final String name); @Override void endEntity(); @Override void literal(final String name, final String value); }
@Test public void testShouldOutputConciseRecordRepresentation() { encoder.setStyle(FormatterStyle.CONCISE); executeEvents(); verify(receiver).process(CONCISE_RECORD); } @Test public void testShouldOutputVerboseRecordRepresentation() { encoder.setStyle(FormatterStyle.VERBOSE); executeEvents(); verify(receiver).process(VERBOSE_RECORD); } @Test public void testShouldOutputMultilineRecordRepresentation() { encoder.setStyle(FormatterStyle.MULTILINE); executeEvents(); verify(receiver).process(MULTILINE_RECORD); }
MarcXmlEncoder extends DefaultStreamPipe<ObjectReceiver<String>> { @Override protected void onResetStream() { if (!atStreamStart) { writeFooter(); } sendAndClearData(); atStreamStart = true; } MarcXmlEncoder(); void omitXmlDeclaration(boolean omitXmlDeclaration); void setXmlVersion(String xmlVersion); void setXmlEncoding(String xmlEncoding); void setFormatted(boolean formatted); @Override void startRecord(final String identifier); @Override void endRecord(); @Override void startEntity(final String name); @Override void endEntity(); @Override void literal(final String name, final String value); }
@Test public void sendAndClearDataWhenOnResetStream() { encoder.onResetStream(); String expected = ""; String actual = resultCollector.toString(); assertEquals(expected, actual); }