Datasets:
Minata
/
512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files
xet
Community
method2testcases
stringlengths
118
3.08k
### Question: Receipt { public void setReceiptData(@NonNull String receiptDataFormat, @NonNull String receiptData) { this.receiptDataFormat = receiptDataFormat; this.receiptData = receiptData; } Receipt(@NonNull String receiptType); Receipt(@NonNull String receiptType, @Nullable String receiptText); void setReceiptData(@NonNull String receiptDataFormat, @NonNull String receiptData); @NonNull String getReceiptType(); @Nullable String getReceiptText(); @Nullable String getReceiptDataFormat(); @Nullable String getReceiptData(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void canSerialiseAsPayload() { String receiptText = "{ \"blah\": \"blah\" }"; Receipt receipt = new Receipt("customer", receiptText); receipt.setReceiptData("json", receiptText); FlowEvent fe = new FlowEvent(EVENT_RECEIPT, receipt); String json = fe.toJson(); System.out.println(json); FlowEvent result = FlowEvent.fromJson(json); Receipt resultData = result.getEventData(Receipt.class); assertThat(resultData).isEqualTo(receipt); }
### Question: Payment extends BaseModel { public static Payment fromJson(String json) { return JsonConverter.deserialize(json, Payment.class); } Payment(); Payment(String flowType, String flowName, Amounts amounts, Basket basket, Customer customer, boolean splitEnabled, Token cardToken, AdditionalData additionalData, String source, String deviceId, String paymentMethod); Payment(String id, String requestSource, String flowType, String flowName, Amounts amounts, Basket basket, Customer customer, boolean splitEnabled, Token cardToken, AdditionalData additionalData, String deviceId, String paymentMethod); @NonNull String getFlowType(); @Nullable String getFlowName(); @NonNull Amounts getAmounts(); @Nullable Basket getBasket(); @Nullable String getPaymentMethod(); @Nullable Customer getCustomer(); boolean isSplitEnabled(); @Nullable Token getCardToken(); @NonNull AdditionalData getAdditionalData(); boolean isExternalId(); @NonNull String getSource(); @Nullable String getDeviceId(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toJson(); static Payment fromJson(String json); }### Answer: @Test(expected = JsonParseException.class) public void invalidJsonWillThrow() { Payment.fromJson("{}ahjj"); }
### Question: PaymentClientImpl extends BaseApiClient implements PaymentClient { @Override @NonNull public Completable initiatePayment(final Payment payment) { if (!isProcessingServiceInstalled(context)) { return Completable.error(NO_FPS_EXCEPTION); } final ChannelClient transactionMessenger = getMessengerClient(FLOW_PROCESSING_SERVICE_COMPONENT); AppMessage appMessage = createAppMessageForPayment(payment, ResponseMechanisms.RESPONSE_SERVICE); return transactionMessenger .sendMessage(appMessage.toJson()) .singleOrError() .ignoreElement() .doFinally(transactionMessenger::closeConnection) .onErrorResumeNext(throwable -> Completable.error(createFlowException(throwable))); } protected PaymentClientImpl(Context context); @NonNull @Override Single<PaymentSettings> getPaymentSettings(); @Override @NonNull Completable initiatePayment(final Payment payment); @Override @NonNull Observable<PaymentResponse> queryPaymentResponses(@NonNull ResponseQuery paymentResponseQuery); }### Answer: @Test public void initiatePaymentShouldSendPaymentViaRequestCorrectly() { pretendFpsIsInstalled(); Payment payment = new PaymentBuilder().withPaymentFlow("blarp").withAmounts(new Amounts(1000, "GBP")).build(); String uuid = payment.getId(); paymentClient.initiatePayment(payment).test(); AppMessage sentAppMessage = callSendAndCaptureMessage(); Request request = Request.fromJson(sentAppMessage.getMessageData()); Payment sentPayment = request.getRequestData().getValue(AppMessageTypes.PAYMENT_MESSAGE, Payment.class); assertThat(sentPayment).isEqualTo(payment); verify(messengerClient).closeConnection(); } @Test public void initiatePaymentShouldErrorIfNoFps() { Payment payment = new PaymentBuilder().withPaymentFlow("blarp").withAmounts(new Amounts(1000, "GBP")).build(); TestObserver<Void> test = paymentClient.initiatePayment(payment).test(); assertThat(test.errors().get(0)).isInstanceOf(FlowException.class); }
### Question: PaymentApi { public static boolean isProcessingServiceInstalled(Context context) { return BaseApiClient.isProcessingServiceInstalled(context); } private PaymentApi(); @NonNull static String getApiVersion(); static boolean isProcessingServiceInstalled(Context context); @NonNull static String getProcessingServiceVersion(Context context); @NonNull static PaymentClient getPaymentClient(Context context); }### Answer: @Test public void checkIsProcessingServiceInstalledReportsFalse() throws Exception { assertThat(PaymentApi.isProcessingServiceInstalled(RuntimeEnvironment.application)).isFalse(); } @Test public void checkIsProcessingServiceInstalledFlagReportsTrue() throws RemoteException { setupMockBoundMessengerService(); assertThat(PaymentApi.isProcessingServiceInstalled(RuntimeEnvironment.application)).isTrue(); }
### Question: SplitModel extends BaseStageModel { public boolean lastTransactionFailed() { return splitRequest.hasPreviousTransactions() && !splitRequest.getLastTransaction().hasProcessedRequestedAmounts() && splitRequest.getLastTransaction().hasDeclinedResponses(); } private SplitModel(Activity activity, SplitRequest splitRequest); private SplitModel(ClientCommunicator clientCommunicator, SplitRequest splitRequest, InternalData senderInternalData); @NonNull static SplitModel fromActivity(Activity activity); @NonNull static SplitModel fromService(ClientCommunicator clientCommunicator, SplitRequest request, InternalData senderInternalData); @NonNull SplitRequest getSplitRequest(); boolean lastTransactionFailed(); void setBaseAmountForNextTransaction(long baseAmount); void setBasketForNextTransaction(Basket basket); @SafeVarargs final void addRequestData(String key, T... values); void setAmountsPaid(Amounts amountsPaid, String paymentMethod); void setAmountsPaid(Amounts amountsPaid, String paymentMethod, AdditionalData paymentReferences); void cancelFlow(); void sendResponse(); void skip(); @Override @NonNull String getRequestJson(); }### Answer: @Test public void shouldReportLastTransactionFailedAsFalseIfNoTransactions() throws Exception { assertThat(splitModel.lastTransactionFailed()).isFalse(); } @Test public void shouldReportLastTransactionFailedAsTrueIfPrevTxnFailed() throws Exception { Basket prevTxnBasket = new Basket("txnOneBasket", new BasketItemBuilder().withLabel("item") .withAmount(totalRequestValue / 2).withQuantity(1).build()); Transaction prevTxn = new Transaction(new Amounts(totalRequestValue / 2, "GBP"), Arrays.asList(prevTxnBasket), null, null); prevTxn.addTransactionResponse(new TransactionResponseBuilder(prevTxn.getId()).decline("failed").build()); prevTransactions.add(prevTxn); assertThat(splitModel.lastTransactionFailed()).isTrue(); }
### Question: SplitModel extends BaseStageModel { public void cancelFlow() { flowResponse.setCancelTransaction(true); sendResponse(); } private SplitModel(Activity activity, SplitRequest splitRequest); private SplitModel(ClientCommunicator clientCommunicator, SplitRequest splitRequest, InternalData senderInternalData); @NonNull static SplitModel fromActivity(Activity activity); @NonNull static SplitModel fromService(ClientCommunicator clientCommunicator, SplitRequest request, InternalData senderInternalData); @NonNull SplitRequest getSplitRequest(); boolean lastTransactionFailed(); void setBaseAmountForNextTransaction(long baseAmount); void setBasketForNextTransaction(Basket basket); @SafeVarargs final void addRequestData(String key, T... values); void setAmountsPaid(Amounts amountsPaid, String paymentMethod); void setAmountsPaid(Amounts amountsPaid, String paymentMethod, AdditionalData paymentReferences); void cancelFlow(); void sendResponse(); void skip(); @Override @NonNull String getRequestJson(); }### Answer: @Test public void cancelFlowShouldSetCancelFlagAndSend() throws Exception { splitModel.cancelFlow(); FlowResponse flowResponse = getSentFlowResponse(); assertThat(flowResponse.shouldCancelTransaction()).isTrue(); }
### Question: SplitModel extends BaseStageModel { public void skip() { sendEmptyResponse(); } private SplitModel(Activity activity, SplitRequest splitRequest); private SplitModel(ClientCommunicator clientCommunicator, SplitRequest splitRequest, InternalData senderInternalData); @NonNull static SplitModel fromActivity(Activity activity); @NonNull static SplitModel fromService(ClientCommunicator clientCommunicator, SplitRequest request, InternalData senderInternalData); @NonNull SplitRequest getSplitRequest(); boolean lastTransactionFailed(); void setBaseAmountForNextTransaction(long baseAmount); void setBasketForNextTransaction(Basket basket); @SafeVarargs final void addRequestData(String key, T... values); void setAmountsPaid(Amounts amountsPaid, String paymentMethod); void setAmountsPaid(Amounts amountsPaid, String paymentMethod, AdditionalData paymentReferences); void cancelFlow(); void sendResponse(); void skip(); @Override @NonNull String getRequestJson(); }### Answer: @Test public void skipShouldSendEmptyResponse() throws Exception { splitModel.skip(); FlowResponse flowResponse = getSentFlowResponse(); assertThat(flowResponse).isEqualTo(new FlowResponse()); }
### Question: PreTransactionModel extends BaseStageModel { public void skip() { sendEmptyResponse(); } private PreTransactionModel(Activity activity, @NonNull TransactionRequest transactionRequest); private PreTransactionModel(ClientCommunicator clientCommunicator, @NonNull TransactionRequest transactionRequest, InternalData senderInternalData); @NonNull static PreTransactionModel fromActivity(Activity activity); @NonNull static PreTransactionModel fromService(ClientCommunicator clientCommunicator, TransactionRequest request, InternalData senderInternalData); @NonNull TransactionRequest getTransactionRequest(); void changeCurrency(String currency, double exchangeRate); void setAdditionalAmount(String identifier, long amount); void setAdditionalAmountAsBaseFraction(String identifier, float fraction); @SafeVarargs final void addRequestData(String key, T... values); void addNewBasket(Basket basket); void applyDiscountsToBasket(String basketId, List<BasketItem> basketItems, String paymentMethod); void setAmountsPaid(Amounts amountsPaid, String paymentMethod); void setPaymentReferences(AdditionalData paymentReferences); void addOrUpdateCustomerDetails(Customer customer); void sendResponse(); void skip(); @Override @NonNull String getRequestJson(); }### Answer: @Test public void skipShouldSendEmptyResponse() throws Exception { preTransactionModel.skip(); FlowResponse flowResponse = getSentFlowResponse(); assertThat(flowResponse).isEqualTo(new FlowResponse()); }
### Question: PreTransactionModel extends BaseStageModel { public void addNewBasket(Basket basket) { checkNotNull(basket, "Basket must not be null"); checkNotEmpty(basket.getBasketItems(), "At least one basket item must be set"); if (basket.getTotalBasketValue() < 0) { throw new IllegalArgumentException("Total basket value must be greater than or equal zero"); } flowResponse.addNewBasket(basket); amountsModifier.offsetBaseAmount(basket.getTotalBasketValue()); } private PreTransactionModel(Activity activity, @NonNull TransactionRequest transactionRequest); private PreTransactionModel(ClientCommunicator clientCommunicator, @NonNull TransactionRequest transactionRequest, InternalData senderInternalData); @NonNull static PreTransactionModel fromActivity(Activity activity); @NonNull static PreTransactionModel fromService(ClientCommunicator clientCommunicator, TransactionRequest request, InternalData senderInternalData); @NonNull TransactionRequest getTransactionRequest(); void changeCurrency(String currency, double exchangeRate); void setAdditionalAmount(String identifier, long amount); void setAdditionalAmountAsBaseFraction(String identifier, float fraction); @SafeVarargs final void addRequestData(String key, T... values); void addNewBasket(Basket basket); void applyDiscountsToBasket(String basketId, List<BasketItem> basketItems, String paymentMethod); void setAmountsPaid(Amounts amountsPaid, String paymentMethod); void setPaymentReferences(AdditionalData paymentReferences); void addOrUpdateCustomerDetails(Customer customer); void sendResponse(); void skip(); @Override @NonNull String getRequestJson(); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionForNegativeNewBasketValue() throws Exception { Basket newBasket = new Basket("newBasket", new BasketItemBuilder().withLabel("item").withAmount(-200).build()); preTransactionModel.addNewBasket(newBasket); }
### Question: SplitRequest extends BaseModel { @NonNull public Amounts getRemainingAmounts() { if (transactions.isEmpty()) { return getRequestedAmounts(); } Amounts processed = getProcessedAmounts(); return Amounts.subtractAmounts(getRequestedAmounts(), processed, false); } SplitRequest(); SplitRequest(Payment sourcePayment, Amounts accumulatedRequestTotals, List<Transaction> transactions); @NonNull Payment getSourcePayment(); @NonNull List<Transaction> getTransactions(); boolean hasPreviousTransactions(); @Nullable Transaction getLastTransaction(); @NonNull Amounts getRequestedAmounts(); @NonNull Amounts getRemainingAmounts(); @NonNull Amounts getProcessedAmounts(); void setDeviceAudience(DeviceAudience deviceAudience); @NonNull DeviceAudience getDeviceAudience(); @Override String toJson(); static SplitRequest fromJson(String json); }### Answer: @Test public void shouldCalculateRemainingAmountsCorrectly() throws Exception { setupSplitRequestWith75PercentProcessed(); Amounts remainingAmounts = splitRequest.getRemainingAmounts(); assertThat(remainingAmounts).isEqualTo(new Amounts(TOTAL_AMOUNT / 4, CURRENCY)); } @Test public void remainingShouldReturnRequestAmountsIfNothingProcessed() throws Exception { setupWithNothingProcessed(); Amounts remainingAmounts = splitRequest.getRemainingAmounts(); assertThat(remainingAmounts).isEqualTo(new Amounts(TOTAL_AMOUNT, CURRENCY)); } @Test public void remainingShouldReturnZeroIfAllProcessed() throws Exception { setupWithAllProcessed(); Amounts remainingAmounts = splitRequest.getRemainingAmounts(); assertThat(remainingAmounts).isEqualTo(new Amounts(0, CURRENCY)); }
### Question: FlowConfig implements Jsonable, JsonPostProcessing { public List<FlowApp> getAppsForStage(String stageName) { if (hasStage(stageName)) { return getStage(stageName).getFlowApps(); } return new ArrayList<>(); } FlowConfig(); FlowConfig(String name, String type, int version, int apiMajorVersion, String description, String restrictedToApp, List<FlowStage> stages, boolean processInBackground, boolean allowZeroAmounts); @NonNull String getName(); @NonNull String getType(); int getVersion(); int getApiMajorVersion(); @Nullable String getDescription(); boolean hasAppRestriction(); boolean isClientAppAllowed(String clientPackageName); List<FlowStage> getStages(boolean flattened); String getRequestClass(); boolean shouldProcessInBackground(); boolean shouldAllowZeroAmounts(); boolean isGeneratedFromCustomType(); void setGeneratedFromCustomType(boolean generatedFromCustomType); synchronized Set<String> getAllStageNames(); synchronized FlowStage getStage(String stageName); synchronized boolean hasStage(String stage); synchronized boolean hasAppForStage(String stage); synchronized boolean hasAppForStage(String appId, String stage); List<FlowApp> getAppsForStage(String stageName); FlowApp getFirstAppForStage(String stageName); boolean containsApp(String flowAppId); synchronized FlowApp getFlowApp(String stage, String appId); void setApps(String stage, List<FlowApp> flowApps); @Override String toJson(); @Override void onJsonDeserialisationCompleted(); static FlowConfig fromJson(String json); @Override boolean equals(Object o); @Override int hashCode(); static final String REQUEST_CLASS_GENERIC; static final String REQUEST_CLASS_PAYMENT; }### Answer: @Test public void canGetAppsForAnyStage() { List<FlowApp> apps = flowConfig.getAppsForStage("sausage"); assertThat(apps).isNotNull(); assertThat(apps).hasSize(0); }
### Question: SplitRequest extends BaseModel { @NonNull public Amounts getProcessedAmounts() { Amounts processed = new Amounts(0, getRequestedAmounts().getCurrency()); if (transactions.isEmpty()) { return processed; } for (Transaction transaction : transactions) { processed = Amounts.addAmounts(processed, transaction.getProcessedAmounts()); } return processed; } SplitRequest(); SplitRequest(Payment sourcePayment, Amounts accumulatedRequestTotals, List<Transaction> transactions); @NonNull Payment getSourcePayment(); @NonNull List<Transaction> getTransactions(); boolean hasPreviousTransactions(); @Nullable Transaction getLastTransaction(); @NonNull Amounts getRequestedAmounts(); @NonNull Amounts getRemainingAmounts(); @NonNull Amounts getProcessedAmounts(); void setDeviceAudience(DeviceAudience deviceAudience); @NonNull DeviceAudience getDeviceAudience(); @Override String toJson(); static SplitRequest fromJson(String json); }### Answer: @Test public void shouldCalculateProcessedAmountsCorrectly() throws Exception { setupSplitRequestWith75PercentProcessed(); Amounts processedAmounts = splitRequest.getProcessedAmounts(); assertThat(processedAmounts).isEqualTo(new Amounts((TOTAL_AMOUNT / 4) * 3, CURRENCY)); } @Test public void processedShouldReturnZeroIfNothingProcessed() throws Exception { setupWithNothingProcessed(); Amounts processedAmounts = splitRequest.getProcessedAmounts(); assertThat(processedAmounts).isEqualTo(new Amounts(0, CURRENCY)); } @Test public void processedShouldReturnTotalIfAllProcessed() throws Exception { setupWithAllProcessed(); Amounts processedAmounts = splitRequest.getProcessedAmounts(); assertThat(processedAmounts).isEqualTo(new Amounts(TOTAL_AMOUNT, CURRENCY)); }
### Question: AmountsModifier { @NonNull public AmountsModifier setAdditionalAmount(String identifier, long amount, boolean allowReduction) { if (amount >= 0) { Long existingValue = additionalAmounts.get(identifier); if (existingValue != null && amount < existingValue && !allowReduction) { throw new IllegalArgumentException("Reducing an existing amount is not allowed"); } additionalAmounts.put(identifier, amount); hasModifications = true; } return this; } AmountsModifier(Amounts originalAmounts); @NonNull AmountsModifier changeCurrency(String currency, double exchangeRate); @NonNull AmountsModifier updateBaseAmount(long baseAmountValue); @NonNull AmountsModifier offsetBaseAmount(long baseAmountOffset); @NonNull AmountsModifier setAdditionalAmount(String identifier, long amount, boolean allowReduction); @NonNull AmountsModifier setAdditionalAmountAsBaseFraction(String identifier, float fraction); boolean hasModifications(); @NonNull Amounts build(); static float percentageToFraction(int percentage); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldNotAllowReducingAdditional() throws Exception { Amounts original = new Amounts(100, "GBP"); original.addAdditionalAmount("cashback", 100); new AmountsModifier(original).setAdditionalAmount("cashback", 50, false); }
### Question: CardBuilder { @NonNull public static String maskPan(String pan) { checkArgument(pan != null && pan.length() >= MIN_PAN_LENGTH, "PAN must be >= " + MIN_PAN_LENGTH + " in length"); byte[] bytes = pan.getBytes(); Arrays.fill(bytes, START_PAN_OFFSET, bytes.length - END_PAN_OFFSET, X_CHAR); return new String(bytes); } @NonNull CardBuilder withMaskedPan(String maskedPan); @NonNull CardBuilder withCardholderName(String cardholderName); @NonNull CardBuilder withExpiryDate(String expiryDate); CardBuilder withCardToken(Token cardToken); @NonNull CardBuilder withAdditionalData(AdditionalData additionalData); @NonNull CardBuilder withAdditionalData(String key, T... values); @NonNull Card build(); @NonNull static String maskPan(String pan); }### Answer: @Test public void shouldMaskPanCorrectly() throws Exception { String maskedPan = CardBuilder.maskPan("1234123412341234"); assertThat(maskedPan).isEqualTo("123412XXXXXX1234"); }
### Question: TransactionResponseBuilder { @NonNull public TransactionResponse build() { checkArgument(id != null && !id.isEmpty(), "Request id must be set"); checkArgument(outcome != null, "Outcome must be set"); return new TransactionResponse(id, card, outcome, outcomeMessage, amounts, responseCode, references, paymentMethod); } TransactionResponseBuilder(String requestId); @NonNull TransactionResponseBuilder withDefaultsFrom(TransactionResponse transactionResponse); @NonNull TransactionResponseBuilder approve(); @NonNull TransactionResponseBuilder approve(Amounts processedAmounts, String... paymentMethod); @NonNull TransactionResponseBuilder decline(String declineMessage); @NonNull TransactionResponseBuilder withCard(Card card); @NonNull TransactionResponseBuilder withOutcomeMessage(String outcomeMessage); @NonNull TransactionResponseBuilder withResponseCode(String responseCode); @NonNull TransactionResponseBuilder withReference(String key, T... values); @NonNull TransactionResponseBuilder withReferences(AdditionalData references); boolean isValid(); @NonNull TransactionResponse build(); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentIfOutcomeNotSet() throws Exception { new TransactionResponseBuilder("1234").build(); }
### Question: PaymentFlowServiceInfoBuilder { @NonNull public PaymentFlowServiceInfoBuilder withCanPayAmounts(boolean canPayAmounts, String... paymentMethods) { if (canPayAmounts && (paymentMethods == null || paymentMethods.length == 0)) { throw new IllegalArgumentException("If canPayAmounts flag is set, payment methods must be provided"); } this.canPayAmounts = canPayAmounts; this.paymentMethods = new HashSet<>(Arrays.asList(paymentMethods)); return this; } @NonNull PaymentFlowServiceInfoBuilder withVendor(String vendor); @NonNull PaymentFlowServiceInfoBuilder withDisplayName(String displayName); @NonNull PaymentFlowServiceInfoBuilder withSupportsAccessibilityMode(boolean supportsAccessibilityMode); @NonNull PaymentFlowServiceInfoBuilder withSupportedFlowTypes(String... flowTypes); @NonNull PaymentFlowServiceInfoBuilder withCustomRequestTypes(String... customRequestTypes); @NonNull PaymentFlowServiceInfoBuilder withSupportedDataKeys(String... supportedDataKeys); @NonNull PaymentFlowServiceInfoBuilder withCanAdjustAmounts(boolean canAdjustAmounts); @NonNull PaymentFlowServiceInfoBuilder withCanPayAmounts(boolean canPayAmounts, String... paymentMethods); @NonNull PaymentFlowServiceInfoBuilder withDefaultCurrency(String defaultCurrency); @NonNull PaymentFlowServiceInfoBuilder withSupportedCurrencies(String... supportedCurrencies); @NonNull PaymentFlowServiceInfoBuilder withAdditionalInfo(String key, T... values); @NonNull PaymentFlowServiceInfoBuilder withAdditionalInfo(AdditionalData additionalInfo); @NonNull AdditionalData getCurrentAdditionalInfo(); @NonNull PaymentFlowServiceInfoBuilder withMerchants(Merchant... merchants); @NonNull PaymentFlowServiceInfoBuilder withManualEntrySupport(boolean manualEntrySupport); @NonNull PaymentFlowServiceInfo build(Context context); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentWhenPaymentMethodsNotSet() throws Exception { paymentFlowServiceInfoBuilder.withCanPayAmounts(true, (String[]) null); }
### Question: FlowConfig implements Jsonable, JsonPostProcessing { public FlowApp getFirstAppForStage(String stageName) { if (hasStage(stageName)) { List<FlowApp> apps = getAppsForStage(stageName); if (apps.size() > 0) { return apps.get(0); } } return null; } FlowConfig(); FlowConfig(String name, String type, int version, int apiMajorVersion, String description, String restrictedToApp, List<FlowStage> stages, boolean processInBackground, boolean allowZeroAmounts); @NonNull String getName(); @NonNull String getType(); int getVersion(); int getApiMajorVersion(); @Nullable String getDescription(); boolean hasAppRestriction(); boolean isClientAppAllowed(String clientPackageName); List<FlowStage> getStages(boolean flattened); String getRequestClass(); boolean shouldProcessInBackground(); boolean shouldAllowZeroAmounts(); boolean isGeneratedFromCustomType(); void setGeneratedFromCustomType(boolean generatedFromCustomType); synchronized Set<String> getAllStageNames(); synchronized FlowStage getStage(String stageName); synchronized boolean hasStage(String stage); synchronized boolean hasAppForStage(String stage); synchronized boolean hasAppForStage(String appId, String stage); List<FlowApp> getAppsForStage(String stageName); FlowApp getFirstAppForStage(String stageName); boolean containsApp(String flowAppId); synchronized FlowApp getFlowApp(String stage, String appId); void setApps(String stage, List<FlowApp> flowApps); @Override String toJson(); @Override void onJsonDeserialisationCompleted(); static FlowConfig fromJson(String json); @Override boolean equals(Object o); @Override int hashCode(); static final String REQUEST_CLASS_GENERIC; static final String REQUEST_CLASS_PAYMENT; }### Answer: @Test public void checkCanGetAppForStageAndWillReturnFirst() { setupDefaultFlowApps(); FlowApp app = flowConfig.getFirstAppForStage("cauliflower"); assertThat(app).isNotNull(); assertThat(app.getId()).isEqualTo("hydrogen"); }
### Question: FlowConfig implements Jsonable, JsonPostProcessing { public synchronized FlowApp getFlowApp(String stage, String appId) { stage = normaliseStageName(stage); if (allStagesMap.containsKey(stage)) { return findAppInList(allStagesMap.get(stage).getFlowApps(), appId); } return null; } FlowConfig(); FlowConfig(String name, String type, int version, int apiMajorVersion, String description, String restrictedToApp, List<FlowStage> stages, boolean processInBackground, boolean allowZeroAmounts); @NonNull String getName(); @NonNull String getType(); int getVersion(); int getApiMajorVersion(); @Nullable String getDescription(); boolean hasAppRestriction(); boolean isClientAppAllowed(String clientPackageName); List<FlowStage> getStages(boolean flattened); String getRequestClass(); boolean shouldProcessInBackground(); boolean shouldAllowZeroAmounts(); boolean isGeneratedFromCustomType(); void setGeneratedFromCustomType(boolean generatedFromCustomType); synchronized Set<String> getAllStageNames(); synchronized FlowStage getStage(String stageName); synchronized boolean hasStage(String stage); synchronized boolean hasAppForStage(String stage); synchronized boolean hasAppForStage(String appId, String stage); List<FlowApp> getAppsForStage(String stageName); FlowApp getFirstAppForStage(String stageName); boolean containsApp(String flowAppId); synchronized FlowApp getFlowApp(String stage, String appId); void setApps(String stage, List<FlowApp> flowApps); @Override String toJson(); @Override void onJsonDeserialisationCompleted(); static FlowConfig fromJson(String json); @Override boolean equals(Object o); @Override int hashCode(); static final String REQUEST_CLASS_GENERIC; static final String REQUEST_CLASS_PAYMENT; }### Answer: @Test public void checkCanGetAppForSpecifiedStage() { setupDefaultFlowApps(); FlowApp app = flowConfig.getFlowApp("cauliflower", "hydrogen"); assertThat(app).isNotNull(); assertThat(app.getId()).isEqualTo("hydrogen"); }
### Question: AdditionalData implements Jsonable { @Nullable public Object getValue(String key, Object... defaultValue) { JsonOption option = data.get(key); if (option != null) { try { return Class.forName(option.getType()).cast(option.getValue()); } catch (ClassNotFoundException e) { } } if (defaultValue.length > 0) { return defaultValue[0]; } return null; } AdditionalData(); AdditionalData(Map<String, JsonOption> data); AdditionalData(AdditionalData copyFrom); boolean isEmpty(); void addData(String key, T... values); void addDataWithType(String key, T value, Class<?> type); void addData(AdditionalData additionalData, boolean allowOverwrite); void removeData(String key); @Nullable Object getAndRemoveData(String key); @Nullable T getAndRemoveData(String key, Class<T> desiredType); void clearData(); boolean hasData(String key); @NonNull Set<String> getKeys(); @Nullable String getValueClassName(String key); @Nullable Object getValue(String key, Object... defaultValue); @NonNull Map<String, T> getDataOfType(Class<T> desiredType); @Nullable T getValue(String key, Class<T> desiredType, T... defaultValue); String getStringValue(String key, String... defaultValue); int getIntegerValue(String key, Integer... defaultValue); boolean getBooleanValue(String key, Boolean... defaultValue); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override String toJson(); static AdditionalData fromJson(String json); }### Answer: @Test public void canGetDefaultValue() throws Exception { assertThat(additionalData.getValue("hello")).isNull(); assertThat(additionalData.getValue("hello", "default")).isEqualTo("default"); assertThat(additionalData.getValue("hello", String.class)).isNull(); assertThat(additionalData.getValue("hello", String.class, "default")).isEqualTo("default"); }
### Question: BaseServiceInfoProvider extends ContentProvider { @Override public final Bundle call(String method, String arg, Bundle extras) { Bundle bundle = new Bundle(); if (method == null || method.isEmpty()) { method = METHOD_GET_SERVICE_INFO; } switch (method) { case METHOD_GET_SERVICE_INFO: bundle.putString(SERVICE_INFO_KEY, getServiceInfo()); break; case METHOD_PROVIDE_ERROR: boolean handled = onServiceInfoError(extras.getString(SERVICE_INFO_ERROR_KEY), extras.getString(SERVICE_INFO_ERROR_DESC_KEY)); bundle.putBoolean(SERVICE_INFO_ERROR_HANDLED_KEY, handled); break; default: break; } return bundle; } protected BaseServiceInfoProvider(String serviceInfoChangeBroadcast); int delete(Uri uri, String selection, String[] selectionArgs); String getType(Uri uri); Uri insert(Uri uri, ContentValues values); boolean onCreate(); Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder); int update(Uri uri, ContentValues values, String selection, String[] selectionArgs); @Override final Bundle call(String method, String arg, Bundle extras); final void notifyServiceInfoChange(); static void notifyServiceInfoChange(Context context, String configChangeBroadcast); static final String SERVICE_INFO_KEY; static final String SERVICE_INFO_ERROR_KEY; static final String SERVICE_INFO_ERROR_DESC_KEY; static final String SERVICE_INFO_ERROR_HANDLED_KEY; static final String METHOD_GET_SERVICE_INFO; static final String METHOD_PROVIDE_ERROR; }### Answer: @Test public void shouldSetServiceInfoInBundleWithCorrectKey() throws Exception { TestServiceInfoProvider serviceInfoProvider = new TestServiceInfoProvider(""); Bundle bundle = serviceInfoProvider.call("", "", null); assertThat(bundle.getString(BaseServiceInfoProvider.SERVICE_INFO_KEY)).isEqualTo(SERVICE_INFO_STRING); }
### Question: BaseServiceInfoProvider extends ContentProvider { public final void notifyServiceInfoChange() { notifyServiceInfoChange(getContext(), serviceInfoChangeBroadcast); } protected BaseServiceInfoProvider(String serviceInfoChangeBroadcast); int delete(Uri uri, String selection, String[] selectionArgs); String getType(Uri uri); Uri insert(Uri uri, ContentValues values); boolean onCreate(); Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder); int update(Uri uri, ContentValues values, String selection, String[] selectionArgs); @Override final Bundle call(String method, String arg, Bundle extras); final void notifyServiceInfoChange(); static void notifyServiceInfoChange(Context context, String configChangeBroadcast); static final String SERVICE_INFO_KEY; static final String SERVICE_INFO_ERROR_KEY; static final String SERVICE_INFO_ERROR_DESC_KEY; static final String SERVICE_INFO_ERROR_HANDLED_KEY; static final String METHOD_GET_SERVICE_INFO; static final String METHOD_PROVIDE_ERROR; }### Answer: @Test public void shouldSendCorrectBroadcastForServiceInfoChange() throws Exception { TestServiceInfoProvider serviceInfoProvider = new TestServiceInfoProvider("my.broadcast"); serviceInfoProvider.notifyServiceInfoChange(); ArgumentCaptor<Intent> broadcastCaptor = ArgumentCaptor.forClass(Intent.class); verify(context).sendBroadcast(broadcastCaptor.capture()); assertThat(broadcastCaptor.getValue().getAction()).isEqualTo("my.broadcast"); assertThat(broadcastCaptor.getValue().getData().toString()).isEqualTo("package:com.test"); }
### Question: MethodRemovalRule implements ComparingValidationRule { @Override public void methodRemoved(final ValidationContext ctx, final MethodDescriptor current) { if (!current.options().getDeprecated()) { ctx.report( ViolationType.WIRE_INCOMPATIBILITY_VIOLATION, "method removed" ); } } private MethodRemovalRule(); static MethodRemovalRule create(); @Override void methodRemoved(final ValidationContext ctx, final MethodDescriptor current); }### Answer: @Test public void testMethodRemoved() throws Exception { final DescriptorSet current = DescriptorSetUtils.buildDescriptorSet( "a.proto", "syntax = 'proto3';\n" + "service Derp {\n" + " rpc GetDerp (HerpDerp) returns (HerpDerp);\n" + "}\n" + "message HerpDerp {}" ); final DescriptorSet candidate = DescriptorSetUtils.buildDescriptorSet( "a.proto", "syntax = 'proto3';\n" + "service Derp {\n" + "}\n" + "message HerpDerp {}" ); final ImmutableList<ValidationViolation> violations = schemaValidator.validate(current, candidate); assertThat( violations, contains( validationViolation() .type(equalTo(ViolationType.WIRE_INCOMPATIBILITY_VIOLATION)) .description(equalTo("method removed")) ) ); }
### Question: FieldRemovalRule implements ComparingValidationRule { @Override public void fieldRemoved(final ValidationContext ctx, final FieldDescriptor current, final MessageDescriptor candidateContainingMessage) { if (candidateContainingMessage.isReservedNumber(current.number()) && candidateContainingMessage.isReservedName(current.name())) { ctx.report( ViolationType.GENERATED_SOURCE_CODE_INCOMPATIBILITY_VIOLATION, "field made reserved" ); } else { ctx.report( ViolationType.GENERATED_SOURCE_CODE_INCOMPATIBILITY_VIOLATION, "field removed" ); } } private FieldRemovalRule(); static FieldRemovalRule create(); @Override void fieldRemoved(final ValidationContext ctx, final FieldDescriptor current, final MessageDescriptor candidateContainingMessage); }### Answer: @Test public void testFieldRemoved() throws Exception { final DescriptorSet current = DescriptorSetUtils.buildDescriptorSet( "a.proto", "syntax = 'proto3';\n" + "message Derp {\n" + " int32 a = 1;\n" + "}" ); final DescriptorSet candidate = DescriptorSetUtils.buildDescriptorSet( "a.proto", "syntax = 'proto3';\n" + "message Derp {\n" + "}" ); final ImmutableList<ValidationViolation> violations = schemaValidator.validate(current, candidate); assertThat( violations, contains( validationViolation() .type(equalTo(ViolationType.GENERATED_SOURCE_CODE_INCOMPATIBILITY_VIOLATION)) .description(equalTo("field removed")) ) ); }
### Question: EnumValueRemovalRule implements ComparingValidationRule { @Override public void enumValueRemoved(final ValidationContext ctx, final EnumValueDescriptor current, final EnumDescriptor candidateContainingEnum) { if (candidateContainingEnum.isReservedNumber(current.number()) && candidateContainingEnum.isReservedName(current.name())) { ctx.report( ViolationType.GENERATED_SOURCE_CODE_INCOMPATIBILITY_VIOLATION, "enum value made reserved" ); } else { ctx.report( ViolationType.GENERATED_SOURCE_CODE_INCOMPATIBILITY_VIOLATION, "enum value removed" ); } } private EnumValueRemovalRule(); static EnumValueRemovalRule create(); @Override void enumValueRemoved(final ValidationContext ctx, final EnumValueDescriptor current, final EnumDescriptor candidateContainingEnum); }### Answer: @Test public void testEnumValueRemoved() throws Exception { final DescriptorSet current = DescriptorSetUtils.buildDescriptorSet( "a.proto", "syntax = 'proto3';\n" + "enum Derp {\n" + " A = 0;\n" + " B = 1;\n" + "}" ); final DescriptorSet candidate = DescriptorSetUtils.buildDescriptorSet( "a.proto", "syntax = 'proto3';\n" + "enum Derp {\n" + " A = 0;\n" + "}" ); final ImmutableList<ValidationViolation> violations = schemaValidator.validate(current, candidate); assertThat( violations, contains( validationViolation() .type(equalTo(ViolationType.GENERATED_SOURCE_CODE_INCOMPATIBILITY_VIOLATION)) .description(equalTo("enum value removed")) ) ); }
### Question: SemverSchemaVersioner implements SchemaVersioner { @VisibleForTesting static String getMajorVersion(final String protoPackage) { final Matcher matcher = MAJOR_VERSION_RE.matcher(protoPackage); if (matcher.matches()) { return matcher.group("major"); } else { return "1"; } } private SemverSchemaVersioner(); static SemverSchemaVersioner create(); @Override SchemaVersion determineVersion(final String protoPackage, @Nullable final SchemaVersion currentVersion, final DescriptorSet current, final DescriptorSet candidate); }### Answer: @Test public void testGetMajorVersion() throws Exception { assertThat(SemverSchemaVersioner.getMajorVersion("herp.derp"), equalTo("1")); assertThat(SemverSchemaVersioner.getMajorVersion("herp.derp.v1"), equalTo("1")); assertThat(SemverSchemaVersioner.getMajorVersion("herp.derp.v3"), equalTo("3")); assertThat(SemverSchemaVersioner.getMajorVersion("herp.derp.v1beta"), equalTo("1beta")); assertThat(SemverSchemaVersioner.getMajorVersion("herp.derp.v1beta2"), equalTo("1beta2")); assertThat(SemverSchemaVersioner.getMajorVersion("herp.derp.v1alpha"), equalTo("1alpha")); assertThat(SemverSchemaVersioner.getMajorVersion("herp.derp.v1alpha3"), equalTo("1alpha3")); assertThat(SemverSchemaVersioner.getMajorVersion("foo.v2.admin.v3"), equalTo("3")); }
### Question: SemverSchemaVersioner implements SchemaVersioner { @Override public SchemaVersion determineVersion(final String protoPackage, @Nullable final SchemaVersion currentVersion, final DescriptorSet current, final DescriptorSet candidate) { final String majorVersion = getMajorVersion(protoPackage); if (currentVersion == null) { return SchemaVersion.create(majorVersion, 0, 0); } Preconditions.checkState(Objects.equals(majorVersion, currentVersion.major())); if (hasMinorVersionChange(protoPackage, current, candidate)) { final int minorVersion = currentVersion.minor() + 1; return SchemaVersion.create(majorVersion, minorVersion, 0); } if (hasPatchVersionChange(protoPackage, current, candidate)) { final int patchVersion = currentVersion.patch() + 1; return SchemaVersion.create(majorVersion, currentVersion.minor(), patchVersion); } return currentVersion; } private SemverSchemaVersioner(); static SemverSchemaVersioner create(); @Override SchemaVersion determineVersion(final String protoPackage, @Nullable final SchemaVersion currentVersion, final DescriptorSet current, final DescriptorSet candidate); }### Answer: @Test @Parameters(method = "testParams") public void testDetermineVersion(final Path root, final String protoPackage, final SchemaVersion currentVersion, final SchemaVersion expectedVersion) throws Exception { final SemverSchemaVersioner sut = SemverSchemaVersioner.create(); final DescriptorSetPair descriptorSetPair = DescriptorSetUtils.buildDescriptorSetPair(root); final SchemaVersion version = sut.determineVersion( protoPackage, currentVersion, descriptorSetPair.current(), descriptorSetPair.candidate() ); assertThat(version, equalTo(expectedVersion)); }
### Question: ProtoIndex { public void updateProtoLocation(final String src, final String dest) { Objects.requireNonNull(src); Objects.requireNonNull(dest); protoLocations.put(src, dest); } private ProtoIndex(final Index index); static ProtoIndex empty(); static ProtoIndex parse(final byte[] bytes); void updateProtoLocation(final String src, final String dest); void updatePackageVersion(final String pkg, final SchemaVersion version); void updateProtoDependencies(final Path proto, final Set<Path> paths); ImmutableSetMultimap<Path, Path> getProtoDependencies(); boolean removeProtoLocation(final String pkg); Map<String, String> getProtoLocations(); Map<String, SchemaVersion> getPackageVersions(); String toProtoString(); @Override String toString(); byte[] toByteArray(); }### Answer: @Test public void updateProtoLocation() { final ProtoIndex protoIndex = ProtoIndex.empty(); protoIndex.updateProtoLocation("/pkg1/protofile.proto", "dest1"); protoIndex.updateProtoLocation("/pkg2/protofile.proto", "dest2"); final ProtoIndex after = ProtoIndex.parse(protoIndex.toByteArray()); assertThat(after.getProtoLocations(), equalTo(ImmutableMap.of( "/pkg1/protofile.proto", "dest1", "/pkg2/protofile.proto", "dest2" ))); }
### Question: ProtoIndex { public boolean removeProtoLocation(final String pkg) { Objects.requireNonNull(pkg); return protoLocations.remove(pkg) != null; } private ProtoIndex(final Index index); static ProtoIndex empty(); static ProtoIndex parse(final byte[] bytes); void updateProtoLocation(final String src, final String dest); void updatePackageVersion(final String pkg, final SchemaVersion version); void updateProtoDependencies(final Path proto, final Set<Path> paths); ImmutableSetMultimap<Path, Path> getProtoDependencies(); boolean removeProtoLocation(final String pkg); Map<String, String> getProtoLocations(); Map<String, SchemaVersion> getPackageVersions(); String toProtoString(); @Override String toString(); byte[] toByteArray(); }### Answer: @Test public void removeProtoLocation() { final ProtoIndex protoIndex = ProtoIndex.empty(); protoIndex.updateProtoLocation("/pkg1/protofile.proto", "dest1"); protoIndex.removeProtoLocation("/pkg1/protofile.proto"); final ProtoIndex after = ProtoIndex.parse(protoIndex.toByteArray()); assertThat(after.getProtoLocations(), equalTo(ImmutableMap.of())); }
### Question: ProtoIndex { public void updatePackageVersion(final String pkg, final SchemaVersion version) { Objects.requireNonNull(pkg); Objects.requireNonNull(version); packageVersions.put(pkg, version); } private ProtoIndex(final Index index); static ProtoIndex empty(); static ProtoIndex parse(final byte[] bytes); void updateProtoLocation(final String src, final String dest); void updatePackageVersion(final String pkg, final SchemaVersion version); void updateProtoDependencies(final Path proto, final Set<Path> paths); ImmutableSetMultimap<Path, Path> getProtoDependencies(); boolean removeProtoLocation(final String pkg); Map<String, String> getProtoLocations(); Map<String, SchemaVersion> getPackageVersions(); String toProtoString(); @Override String toString(); byte[] toByteArray(); }### Answer: @Test public void updatePackageVersion() { final ProtoIndex protoIndex = ProtoIndex.empty(); protoIndex.updatePackageVersion("pkg1", SchemaVersion.create("1",0,0)); final ProtoIndex after = ProtoIndex.parse(protoIndex.toByteArray()); assertThat(after.getPackageVersions(), equalTo(ImmutableMap.of( "pkg1", SchemaVersion.create("1",0,0) ))); }
### Question: ProtoIndex { public void updateProtoDependencies(final Path proto, final Set<Path> paths) { protoDependencies.replaceValues(proto, paths); } private ProtoIndex(final Index index); static ProtoIndex empty(); static ProtoIndex parse(final byte[] bytes); void updateProtoLocation(final String src, final String dest); void updatePackageVersion(final String pkg, final SchemaVersion version); void updateProtoDependencies(final Path proto, final Set<Path> paths); ImmutableSetMultimap<Path, Path> getProtoDependencies(); boolean removeProtoLocation(final String pkg); Map<String, String> getProtoLocations(); Map<String, SchemaVersion> getPackageVersions(); String toProtoString(); @Override String toString(); byte[] toByteArray(); }### Answer: @Test public void updateProtoDependencies() { final Path path1 = Paths.get("/pkg1/proto1.proto"); final Path path2 = Paths.get("/pkg2/proto2.proto"); final Path path3 = Paths.get("/pkg3/proto3.proto"); final ProtoIndex protoIndex = ProtoIndex.empty(); protoIndex.updateProtoDependencies(path1, ImmutableSet.of(path1, path2)); protoIndex.updateProtoDependencies(path2, ImmutableSet.of(path3)); final ProtoIndex after = ProtoIndex.parse(protoIndex.toByteArray()); assertThat(after.getProtoDependencies(), equalTo(ImmutableSetMultimap.of( path1, path1, path1, path2, path2, path3 ))); }
### Question: ProtocDescriptorBuilder implements DescriptorBuilder { @Override public Result buildDescriptor(final Stream<Path> paths) throws DescriptorBuilderException { final ImmutableList<Path> pathsList = paths.collect(toImmutableList()); if (pathsList.isEmpty()) { return Result.create(DescriptorProtos.FileDescriptorSet.getDefaultInstance()); } try { return buildFileDescriptorSet(pathsList); } catch (InterruptedException | IOException e) { throw new DescriptorBuilderException(e); } } private ProtocDescriptorBuilder(final Path protocPath, final TemporaryFileStorage fileStorage); static ProtocDescriptorBuilder create(final Path protocPath); static Factory factory(final Path protocPath); static FactoryBuilder factoryBuilder(); @Override DescriptorBuilder setProtoFile(final Path path, final String content); @Override Result buildDescriptor(final Stream<Path> paths); @Override void close(); }### Answer: @Test public void testBuildDescriptor() throws Exception { final DescriptorBuilder sut = ProtocDescriptorBuilder.factoryBuilder() .build() .newDescriptorBuilder(); final Path path1 = Paths.get("foo/bar/1.proto"); final Path path2 = Paths.get("foo/bar/2.proto"); sut.setProtoFile(path1, "syntax = 'proto2'; message One {}"); sut.setProtoFile(path2, "syntax = 'proto3'; message Two {}"); final DescriptorBuilder.Result result = sut.buildDescriptor(Stream.of(path1, path2)); assertThat( result.compilationError(), is(nullValue()) ); assertThat(result.fileDescriptorSet().getFileList(), hasSize(2)); }
### Question: MessageFormat { public static String format(String pattern, Object... arguments) { String msg = pattern; if (arguments != null) { for (int index = 0; index < arguments.length; index++) { msg = msg.replaceAll("\\{" + (index + 1) + "\\}", String.valueOf(arguments[index])); } } return msg; } static String format(String pattern, Object... arguments); }### Answer: @Test public void test() { Assert.assertEquals(MessageFormat.format("{1} {2} {1}", new Object[] { "1", "2" }), "1 2 1"); Assert.assertEquals(MessageFormat.format("{1} is a {2}", new Object[] { "This", "test" }), "This is a test"); Assert.assertEquals(MessageFormat.format("{1} is a {2}", new Object[] { "This", "test", "test", "test" }), "This is a test"); Assert.assertEquals(MessageFormat.format("{1} {2} {1}", new Object[0]), "{1} {2} {1}"); Assert.assertEquals(MessageFormat.format("{1} {2} {1}", (Object[]) null), "{1} {2} {1}"); }
### Question: EnumHelper { @SuppressWarnings("unchecked") public static <E extends Enum<? extends Style.HasCssName>> E fromStyleName(final String styleName, final Class<E> enumClass, final E defaultValue) { if (styleName == null || enumClass == null) { return defaultValue; } for (final Enum<? extends Style.HasCssName> constant : enumClass.getEnumConstants()) { final Style.HasCssName anEnum = (Style.HasCssName) constant; final String cssClass = anEnum.getCssName(); if (cssClass != null && StyleHelper.containsStyle(styleName, cssClass)) { return (E) anEnum; } } return defaultValue; } private EnumHelper(); @SuppressWarnings("unchecked") static E fromStyleName(final String styleName, final Class<E> enumClass, final E defaultValue); }### Answer: @Test public void testFromStyleName() { assertThat(fromStyleName("123 pull-left abc", Pull.class, null), is(Pull.LEFT)); assertThat(fromStyleName("123 pull-right abc", Pull.class, null), is(Pull.RIGHT)); assertThat(fromStyleName("pull-left pull-right abc", Pull.class, null), is(Pull.LEFT)); assertThat(fromStyleName("123 abc", Pull.class, null), is(nullValue())); assertThat(fromStyleName("123 abc", Pull.class, Pull.LEFT), is(Pull.LEFT)); assertThat(fromStyleName("123 abc", null, null), is(nullValue())); assertThat(fromStyleName(null, Pull.class, null), is(nullValue())); }
### Question: StyleHelper { public static boolean containsStyle(final String styleNames, final String style) { if (styleNames == null || style == null) { return false; } final String[] styles = styleNames.split("\\s"); for (final String s : styles) { if (style.equals(s)) { return true; } } return false; } private StyleHelper(); static void addUniqueEnumStyleName(final UIObject uiObject, final Class<F> enumClass, final E style); static void removeEnumStyleNames(final UIObject uiObject, final Class<E> enumClass); static void addEnumStyleName(final UIObject uiObject, final E style); static void removeEnumStyleName(final UIObject uiObject, final E style); static boolean containsStyle(final String styleNames, final String style); static void toggleStyleName(final UIObject uiObject, final boolean toggleStyle, final String styleName); static void setHiddenOn(final UIObject uiObject, final DeviceSize deviceSize); static void setVisibleOn(final UIObject uiObject, final DeviceSize deviceSize); }### Answer: @Test public void testContainsStyle() { final String styleNames = "abc-efg 123 hji-klm"; assertThat(containsStyle(styleNames, "abc-efg"), is(true)); assertThat(containsStyle(styleNames, "123"), is(true)); assertThat(containsStyle(styleNames, "hji-klm"), is(true)); assertThat(containsStyle(styleNames, "mno"), is(false)); assertThat(containsStyle(null, "hji-klm"), is(false)); assertThat(containsStyle(styleNames, null), is(false)); assertThat(containsStyle("abc", "abc"), is(true)); }
### Question: JsonBinding implements SemanticGraphIO { @Override public void read(InputStream in, ReadStatementListener listener) throws IOException, SemanticIOException { throw new NotYetImplementedException(); } @Override void read(InputStream in, ReadStatementListener listener); @Override SemanticGraph read(final InputStream in); @Override void write(final SemanticGraph graph, final OutputStream out); @Override void write(StatementContainer container, OutputStream out); }### Answer: @Test public void testJsonWriter() throws RDFHandlerException, IOException, SemanticIOException{ final SemanticGraph graph = new RdfXmlBinding().read(getClass().getClassLoader().getResourceAsStream("n04.aras.rdf")); Assert.assertNotNull(graph); }
### Question: LuceneQueryBuilder extends QueryBuilder { @Override protected QueryExpression getRoot() { return super.getRoot(); } LuceneQueryBuilder(IndexSearcher searcher, QNResolver resolver); @Override QueryResult getResult(); }### Answer: @Test public void testQueryBuilder() { final LuceneQueryBuilder query = new LuceneQueryBuilder(null, null); query.beginAnd() .add(new FieldParam("a", 1)) .add(new FieldParam("b", 2)) .add(new FieldParam("c", 3)) .beginOr() .add(new FieldParam("d1", 1)) .add(new FieldParam("d2", 2)) .add(new FieldParam("d3", 3)) .end(); final QueryExpression root = query.getRoot(); Assert.assertTrue(root != null); Assert.assertEquals(4, root.getChildren().size()); Assert.assertEquals(3, root.getChildren().get(3).getChildren().size()); }
### Question: MiscUtils { public static String resolveFile(String fileName, String topDir) { File file = new File(fileName); if (!file.isAbsolute()) { file = new File(topDir, fileName); } if (!file.exists()) { List<File> files = getDirectoryList(file.getParentFile(), file.getName()); if (files.size() == 1) { file = files.get(0); } else if (files.size() > 1) { throw new IllegalArgumentException("Found more than 1 file, name: " + fileName + " dir:" + topDir); } else { throw new IllegalArgumentException("File does not exist: " + file.getAbsolutePath()); } } return file.getAbsoluteFile().getAbsolutePath(); } static File combinePath(List<String> paths); static String resolveFile(String fileName, String topDir); static List<File> getDirectoryList(File dir, String glob); static boolean equals(ChaincodeID chaincodeID, Query.ChaincodeInfo chaincodeInfo); static T runWithRetries(int maxRetries, int delaySec, Callable<T> t); }### Answer: @Test public void testResolveFilePositive() { assertTrue(MiscUtils.resolveFile("README.md", ".").contains("README.md")); assertTrue(MiscUtils.resolveFile("*.md", ".").contains("README.md")); assertTrue(MiscUtils.resolveFile("fabric-connector/*.md", "..").contains("README.md")); } @Test(expected = IllegalArgumentException.class) public void testResolveFileByFileNameNegative() { MiscUtils.resolveFile("README.md2", "."); } @Test(expected = IllegalArgumentException.class) public void testResolveFileByGlobNegative() { MiscUtils.resolveFile("*.md2", "."); } @Test(expected = IllegalArgumentException.class) public void testResolveFileByGlobMoreThen1Negative() { MiscUtils.resolveFile("*", "."); }
### Question: Trie implements Serializable { public boolean hasPrefix( String key ) { return ( this.get( key ) != null ); } Trie(); Trie( char key ); void put( String key, V value ); V get( String key ); boolean hasPrefix( String key ); String getCommonPrefix(); @Override String toString(); }### Answer: @Test public void testHasPrefix() { Trie<String> trie = new Trie<>(); trie.put( "a", "a" ); trie.put( "aa", "aa" ); trie.put( "aaa", "aaa" ); trie.put( "ab", "ab" ); trie.put( "abb", "abb" ); trie.put( "aabb", "aabb" ); assertTrue( trie.hasPrefix( "a" ) ); assertTrue( trie.hasPrefix( "aa" ) ); assertTrue( trie.hasPrefix( "aaa" ) ); assertFalse( trie.hasPrefix( "" ) ); assertFalse( trie.hasPrefix( "5" ) ); assertFalse( trie.hasPrefix( "zzzz" ) ); }
### Question: Trie implements Serializable { public String getCommonPrefix() { StringBuffer buffer = new StringBuffer(); if( children.size() != 1 ) return buffer.toString(); buildPrefix( buffer, this ); return buffer.toString(); } Trie(); Trie( char key ); void put( String key, V value ); V get( String key ); boolean hasPrefix( String key ); String getCommonPrefix(); @Override String toString(); }### Answer: @Test public void testGetCommonPrefix() { Trie<String> trie = new Trie<>(); trie.put( "a", "a" ); trie.put( "aa", "aa" ); trie.put( "aaa", "aaa" ); trie.put( "aabb", "aabb" ); trie.put( "aaabb", "aaabb" ); trie.put( "aacbb", "aacbb" ); assertEquals( "aa", trie.getCommonPrefix() ); }
### Question: DictionaryPresenter { void setKeyboardMessageVisibility() { if (packageHelper.isAppInstalled()) { dictionaryView.hideKeyboardMessage(); } else { dictionaryView.showKeyboardMessage(); } } DictionaryPresenter(SozlikDao sozlikDao, PackageHelper packageHelper, SpellChecker spellChecker); void setView(DictionaryView dictionaryView); }### Answer: @Test public void hideKeyboardLinkIfAppInstalled() { when(packageHelperMock.isAppInstalled()).thenReturn(true); dictionaryPresenter.setKeyboardMessageVisibility(); verify(dictionaryViewMock, times(1)).hideKeyboardMessage(); verifyNoMoreInteractions(dictionaryViewMock); } @Test public void showKeyboardLinkIfAppNotInstalled() { when(packageHelperMock.isAppInstalled()).thenReturn(false); dictionaryPresenter.setKeyboardMessageVisibility(); verify(dictionaryViewMock, times(1)).showKeyboardMessage(); verifyNoMoreInteractions(dictionaryViewMock); }
### Question: TranslationPresenter { void getTranslation() { if (model != null) { translationView.showWord(model.getRawWord()); translationView.showTranslation(model.getTranslation()); translationView.setFromFlags(model.getFromResource()); translationView.setToFlags(model.getToResource()); } } TranslationPresenter(SozlikDao sozlikDao); }### Answer: @Test public void whenTranslationIsFoundShowIt() { when(sozlikDbModelMock.getWord()).thenReturn(SOME_WORD); when(sozlikDbModelMock.getTranslation()).thenReturn(SOME_TRANSLATION); when(sozlikDbModelMock.getToResource()).thenReturn(SOME_RESOURCE); when(sozlikDbModelMock.getFromResource()).thenReturn(SOME_RESOURCE); translationPresenter.getTranslation(); verify(translationViewMock, times(1)).showWord(sozlikDbModelMock.getRawWord()); verify(translationViewMock, times(1)).showTranslation(sozlikDbModelMock.getTranslation()); verify(translationViewMock, times(1)).setToFlags(sozlikDbModelMock.getToResource()); verify(translationViewMock, times(1)).setFromFlags(sozlikDbModelMock.getFromResource()); verifyNoMoreInteractions(translationViewMock); }
### Question: TranslationPresenter { void toggleFavorite() { if (model != null) { boolean isFavourite = !model.isFavourite(); model.setFavourite(isFavourite); sozlikDao.update(model); translationView.showFavorite(isFavourite); } } TranslationPresenter(SozlikDao sozlikDao); }### Answer: @Test public void whenWordIsFavoritedToggleRemovesFromFavorites() { when(sozlikDbModelMock.isFavourite()).thenReturn(true); translationPresenter.toggleFavorite(); verify(sozlikDaoMock, times(1)).update(sozlikDbModelMock); verify(translationViewMock, times(1)).showFavorite(false); verify(sozlikDbModelMock, times(1)).setFavourite(false); verifyNoMoreInteractions(translationViewMock); } @Test public void whenWordIsNotFavoritedToggleAddsToFavorites() { when(sozlikDbModelMock.isFavourite()).thenReturn(false); translationPresenter.toggleFavorite(); verify(sozlikDaoMock, times(1)).update(sozlikDbModelMock); verify(translationViewMock, times(1)).showFavorite(true); verify(sozlikDbModelMock, times(1)).setFavourite(true); verifyNoMoreInteractions(translationViewMock); }
### Question: TranslationPresenter { void setFavoriteStatus() { if (model != null) { translationView.showFavorite(model.isFavourite()); } } TranslationPresenter(SozlikDao sozlikDao); }### Answer: @Test public void whenWordIsFavoritedReturnSetFavoriteStatusAsTrue() { when(sozlikDbModelMock.isFavourite()).thenReturn(true); translationPresenter.setFavoriteStatus(); verify(translationViewMock, times(1)).showFavorite(true); verifyNoMoreInteractions(translationViewMock); } @Test public void whenWordIsNotFavoritedReturnSetFavoriteStatusAsFalse() { when(sozlikDbModelMock.isFavourite()).thenReturn(false); translationPresenter.setFavoriteStatus(); verify(translationViewMock, times(1)).showFavorite(false); verifyNoMoreInteractions(translationViewMock); }
### Question: TranslationPresenter { void shareTranslation() { if (model != null) { translationView.goToShare(model.getWord(), model.getMessageForShare()); } } TranslationPresenter(SozlikDao sozlikDao); }### Answer: @Test public void whenShareTranslationShowShareMessage() { when(sozlikDbModelMock.getWord()).thenReturn(SOME_WORD); when(sozlikDbModelMock.getMessageForShare()).thenReturn(SOME_TRANSLATION); translationPresenter.shareTranslation(); verify(translationViewMock, times(1)).goToShare(SOME_WORD, SOME_TRANSLATION); verifyNoMoreInteractions(translationViewMock); }
### Question: TranslationPresenter { void setLastAccessed(long time) { if (model != null) { model.setLastAccessed(time); sozlikDao.update(model); } } TranslationPresenter(SozlikDao sozlikDao); }### Answer: @Test public void whenTranslationIsOpenedSetLastAccessTime() { translationPresenter.setLastAccessed(TIME); verify(sozlikDbModelMock, times(1)).setLastAccessed(TIME); verify(sozlikDaoMock, times(1)).update(sozlikDbModelMock); verifyNoMoreInteractions(sozlikDbModelMock); }
### Question: FavoritesPresenter { void showFavoritesList() { List<SozlikDbModel> list = sozlikDao.getAllFavorites(); if (list != null) { if (list.isEmpty()) { view.hideList(); view.showEmptyScreen(); } else { view.hideEmptyScreen(); view.showList(); view.showFavorites(list); } } } FavoritesPresenter(SozlikDao sozlikDao); void setView(FavoritesView view); }### Answer: @Test public void whenFavoritesListIsNullDoNothing() { when(sozlikDaoMock.getAllFavorites()).thenReturn(null); favoritesPresenter.showFavoritesList(); verifyNoMoreInteractions(favoritesViewMock); } @Test public void whenFavoritesListIsEmptyShowEmptyScreenMessage() { List<SozlikDbModel> list = new ArrayList<>(); when(sozlikDaoMock.getAllFavorites()).thenReturn(list); favoritesPresenter.showFavoritesList(); verify(favoritesViewMock, times(1)).hideList(); verify(favoritesViewMock, times(1)).showEmptyScreen(); verifyNoMoreInteractions(favoritesViewMock); } @Test public void whenFavoritesListIsNotEmptyShowList() { List<SozlikDbModel> list = new ArrayList<>(); list.add(new SozlikDbModel()); when(sozlikDaoMock.getAllFavorites()).thenReturn(list); favoritesPresenter.showFavoritesList(); verify(favoritesViewMock, times(1)).hideEmptyScreen(); verify(favoritesViewMock, times(1)).showList(); verify(favoritesViewMock, times(1)).showFavorites(list); verifyNoMoreInteractions(favoritesViewMock); }
### Question: FavoritesPresenter { void deleteFavorite(SozlikDbModel dbModel) { if (dbModel != null) { dbModel.setFavourite(false); sozlikDao.update(dbModel); } } FavoritesPresenter(SozlikDao sozlikDao); void setView(FavoritesView view); }### Answer: @Test public void whenModelIsNotNullDeleteFavorite() { favoritesPresenter.deleteFavorite(sozlikDbModelMock); verify(sozlikDbModelMock, times(1)).setFavourite(false); verify(sozlikDaoMock, times(1)).update(sozlikDbModelMock); verifyNoMoreInteractions(sozlikDaoMock); verifyNoMoreInteractions(sozlikDbModelMock); } @Test public void whenModelIsNullDoNothing() { favoritesPresenter.deleteFavorite(null); verifyNoMoreInteractions(sozlikDbModelMock); verifyNoMoreInteractions(sozlikDaoMock); }
### Question: TrasierEndpointConfiguration { public String getAuthEndpoint() { return authEndpoint; } String getHttpEndpoint(); void setHttpEndpoint(String httpEndpoint); String getGrpcEndpoint(); void setGrpcEndpoint(String grpcEndpoint); String getAuthEndpoint(); void setAuthEndpoint(String authEndpoint); }### Answer: @Test public void getAuthEndpoint() { TrasierEndpointConfiguration configuration = new TrasierEndpointConfiguration(); configuration.setAuthEndpoint("auth"); assertEquals("auth", configuration.getAuthEndpoint()); }
### Question: Precondition { public static <T> T notNull(T value, String fieldName) { if (value == null) { throw new IllegalArgumentException("Argument " + fieldName + " cannot be null."); } return value; } static T notNull(T value, String fieldName); static String notBlank(String value, String fieldName); }### Answer: @Test(expected = IllegalArgumentException.class) public void throwsOnNullArgument() { Precondition.notNull(null, null); }
### Question: Precondition { public static String notBlank(String value, String fieldName) { if (value == null || value.trim().length() < 1) { throw new IllegalArgumentException("Argument " + fieldName + " cannot be empty."); } return value; } static T notNull(T value, String fieldName); static String notBlank(String value, String fieldName); }### Answer: @Test(expected = IllegalArgumentException.class) public void throwsOnBlankArgument() { Precondition.notBlank(" ", null); }
### Question: ProjectUtils { public static String getProjectVersion() { return projectVersion; } static String getProjectVersion(); }### Answer: @Test public void testPropertyUnset() { String projectVersion = ProjectUtils.getProjectVersion(); assertNotNull(projectVersion); assertNotEquals("unknown", projectVersion); }
### Question: ExceptionUtils { public static String getString(Throwable throwable) { if (throwable == null) { return null; } StringWriter stringWriter = new StringWriter(); throwable.printStackTrace(new PrintWriter(stringWriter)); return stringWriter.toString(); } static String getString(Throwable throwable); }### Answer: @Test public void testStackTrace() { RuntimeException oops = new RuntimeException("oops"); String result = ExceptionUtils.getString(oops); assertTrue(result.startsWith("java.lang.RuntimeException: oops")); }
### Question: ContentTypeResolver { public static ContentType resolveFromPayload(String payload) { if (payload != null) { if (payload.startsWith("<")) { return ContentType.XML; } else if (payload.startsWith("{") || payload.startsWith("[")) { return ContentType.JSON; } else if (!payload.isEmpty()) { return ContentType.TEXT; } } return null; } static ContentType resolveFromPayload(String payload); }### Answer: @Test public void resolveContentType() { assertEquals(ContentType.XML, resolveFromPayload("<project></project>")); assertEquals(ContentType.JSON, resolveFromPayload("{project:[version: 123]}")); assertEquals(ContentType.TEXT, resolveFromPayload("Hello")); }
### Question: OAuthToken { public String getAccessToken() { return accessToken; } String getAccessToken(); void setAccessToken(String accessToken); String getExpiresIn(); void setExpiresIn(String expiresIn); String getRefreshToken(); void setRefreshToken(String refreshToken); String getRefreshExpiresIn(); void setRefreshExpiresIn(String refreshExpiresIn); String getSessionState(); void setSessionState(String sessionState); }### Answer: @Test public void getAccessToken() { OAuthToken token = new OAuthToken(); token.setAccessToken("at"); Assert.assertEquals("at", token.getAccessToken()); }
### Question: OAuthToken { public String getExpiresIn() { return expiresIn; } String getAccessToken(); void setAccessToken(String accessToken); String getExpiresIn(); void setExpiresIn(String expiresIn); String getRefreshToken(); void setRefreshToken(String refreshToken); String getRefreshExpiresIn(); void setRefreshExpiresIn(String refreshExpiresIn); String getSessionState(); void setSessionState(String sessionState); }### Answer: @Test public void getExpiresIn() { OAuthToken token = new OAuthToken(); token.setExpiresIn("1"); Assert.assertEquals("1", token.getExpiresIn()); }
### Question: OAuthToken { public String getRefreshToken() { return refreshToken; } String getAccessToken(); void setAccessToken(String accessToken); String getExpiresIn(); void setExpiresIn(String expiresIn); String getRefreshToken(); void setRefreshToken(String refreshToken); String getRefreshExpiresIn(); void setRefreshExpiresIn(String refreshExpiresIn); String getSessionState(); void setSessionState(String sessionState); }### Answer: @Test public void getRefreshToken() { OAuthToken token = new OAuthToken(); token.setRefreshToken("rt"); Assert.assertEquals("rt", token.getRefreshToken()); }
### Question: OAuthToken { public String getRefreshExpiresIn() { return refreshExpiresIn; } String getAccessToken(); void setAccessToken(String accessToken); String getExpiresIn(); void setExpiresIn(String expiresIn); String getRefreshToken(); void setRefreshToken(String refreshToken); String getRefreshExpiresIn(); void setRefreshExpiresIn(String refreshExpiresIn); String getSessionState(); void setSessionState(String sessionState); }### Answer: @Test public void getRefreshExpiresIn() { OAuthToken token = new OAuthToken(); token.setRefreshExpiresIn("2"); Assert.assertEquals("2", token.getRefreshExpiresIn()); }
### Question: Manifest { Optional<String> fetch(final String assetName) { log.fine(() -> String.format("Fetching asset '%s'", assetName)); Optional<String> rv; try { final Map<String, String> values = getValues(); rv = Optional.ofNullable(values.get(assetName)).map(a -> a.replaceFirst("^/", "")); } catch (IOException e) { log.log(Level.WARNING, e, () -> String.format("Could not load manifestResource from %s", manifestResource)); rv = Optional.empty(); } if (!rv.isPresent()) { log.warning(() -> String.format("The asset '%s' was not in the manifestResource", assetName)); } return rv; } Manifest(final ObjectMapper objectMapper, final Resource manifestResource); }### Answer: @Test void fetchShouldWork() { final Manifest manifest = new Manifest(objectMapper, new ClassPathResource("fetchShouldWork.json")); assertThat(manifest.fetch("bums")).isEmpty(); assertThat(manifest.fetch("app.js")).contains("app-723a7d7a249d998465d650e19bdca289.js"); assertThat(manifest.fetch("app2.js")).contains("app2.js"); } @Test void fetchShouldHandleBrokenManifest() { final Manifest manifest = new Manifest(objectMapper, new ClassPathResource("broken.json")); assertThat(manifest.fetch("app.js")).isEmpty(); }
### Question: FeaturesConfigReader extends AbstractConfigReader { public FeatureDesc[] getFeatureDescs(){ return featureDescs; } FeaturesConfigReader(String fileName); FeaturesConfigReader(SolrResourceLoader loader, String fileName); FeatureDesc[] getFeatureDescs(); FeatureDesc getFeatureDesc(String name); static FieldFeatureExtractorFactory loadFactory(FeaturesConfigReader.FeatureDesc featureDesc); }### Answer: @Test public void testLoader() throws Exception { FeaturesConfigReader fcReader = new FeaturesConfigReader(loader, "ltr_features.conf"); FeaturesConfigReader.FeatureDesc[] featureDescs = fcReader.getFeatureDescs(); assertEquals(featureDescs.length, 4); assertEquals("name=TF in title,class=org.ltr4l.lucene.solr.server.FieldFeatureTFExtractorFactory,params=title", featureDescs[0].toString()); assertEquals("name=TF in body,class=org.ltr4l.lucene.solr.server.FieldFeatureTFExtractorFactory,params=body", featureDescs[1].toString()); assertEquals("name=IDF in title,class=org.ltr4l.lucene.solr.server.FieldFeatureIDFExtractorFactory,params=title", featureDescs[2].toString()); assertEquals("name=IDF in body,class=org.ltr4l.lucene.solr.server.FieldFeatureIDFExtractorFactory,params=body", featureDescs[3].toString()); }
### Question: FeaturesConfigReader extends AbstractConfigReader { public FeatureDesc getFeatureDesc(String name){ return fdMap.get(name); } FeaturesConfigReader(String fileName); FeaturesConfigReader(SolrResourceLoader loader, String fileName); FeatureDesc[] getFeatureDescs(); FeatureDesc getFeatureDesc(String name); static FieldFeatureExtractorFactory loadFactory(FeaturesConfigReader.FeatureDesc featureDesc); }### Answer: @Test public void testGetFeatureDesc() throws Exception { FeaturesConfigReader fcReader = new FeaturesConfigReader(loader,"ltr_features.conf"); assertEquals("name=TF in title,class=org.ltr4l.lucene.solr.server.FieldFeatureTFExtractorFactory,params=title", fcReader.getFeatureDesc("TF in title").toString()); assertEquals("name=TF in body,class=org.ltr4l.lucene.solr.server.FieldFeatureTFExtractorFactory,params=body", fcReader.getFeatureDesc("TF in body").toString()); assertEquals("name=IDF in title,class=org.ltr4l.lucene.solr.server.FieldFeatureIDFExtractorFactory,params=title", fcReader.getFeatureDesc("IDF in title").toString()); assertEquals("name=IDF in body,class=org.ltr4l.lucene.solr.server.FieldFeatureIDFExtractorFactory,params=body", fcReader.getFeatureDesc("IDF in body").toString()); }
### Question: FeaturesConfigReader extends AbstractConfigReader { public static FieldFeatureExtractorFactory loadFactory(FeaturesConfigReader.FeatureDesc featureDesc){ ClassLoader loader = Thread.currentThread().getContextClassLoader(); try { Class<? extends FieldFeatureExtractorFactory> cls = (Class<? extends FieldFeatureExtractorFactory>) loader.loadClass(featureDesc.klass); Class<?>[] types = {String.class, String.class}; Constructor<? extends FieldFeatureExtractorFactory> constructor; constructor = cls.getConstructor(types); return constructor.newInstance(featureDesc.name, featureDesc.param); } catch (Exception e) { throw new RuntimeException(e); } } FeaturesConfigReader(String fileName); FeaturesConfigReader(SolrResourceLoader loader, String fileName); FeatureDesc[] getFeatureDescs(); FeatureDesc getFeatureDesc(String name); static FieldFeatureExtractorFactory loadFactory(FeaturesConfigReader.FeatureDesc featureDesc); }### Answer: @Test public void testLoadFactory() throws Exception { FeaturesConfigReader fcReader = new FeaturesConfigReader(loader,"ltr_features.conf"); assertEquals(FieldFeatureTFExtractorFactory.class, FeaturesConfigReader.loadFactory(fcReader.getFeatureDesc("TF in title")).getClass()); assertEquals(FieldFeatureTFExtractorFactory.class, FeaturesConfigReader.loadFactory(fcReader.getFeatureDesc("TF in body")).getClass()); assertEquals(FieldFeatureIDFExtractorFactory.class, FeaturesConfigReader.loadFactory(fcReader.getFeatureDesc("IDF in title")).getClass()); assertEquals(FieldFeatureIDFExtractorFactory.class, FeaturesConfigReader.loadFactory(fcReader.getFeatureDesc("IDF in body")).getClass()); }
### Question: TrainingDataReader extends AbstractConfigReader { public int getTotalDocs(){ return totalDocs; } TrainingDataReader(String content); String getIdField(); QueryDataDesc[] getQueryDataDescs(); int getTotalDocs(); }### Answer: @Test public void testGetTotalDocs() throws Exception { TrainingDataReader tdReader = new TrainingDataReader(JSON_DATA); assertEquals(10, tdReader.getTotalDocs()); }
### Question: ComposerFormatAttributesExtractor extends ComponentSupport { @VisibleForTesting void extractAuthorPart(final Map<String, Object> author, final List<String> parts, final String key, final String format) { Object part = author.get(key); if (part instanceof String) { parts.add(String.format(format, part)); } } @Inject ComposerFormatAttributesExtractor(final ComposerJsonExtractor composerJsonExtractor); void extractFromZip(final TempBlob tempBlob, final NestedAttributesMap formatAttributes); }### Answer: @Test public void extractAuthorPartMissing() { List<String> parts = new ArrayList<>(); underTest.extractAuthorPart(emptyMap(), parts, "part", "%s"); assertThat(parts, is(empty())); } @Test public void extractAuthorPartNull() { List<String> parts = new ArrayList<>(); underTest.extractAuthorPart(Collections.singletonMap("part", null), parts, "part", "%s"); assertThat(parts, is(empty())); } @Test public void extractAuthorPartNonStringValue() { List<String> parts = new ArrayList<>(); underTest.extractAuthorPart(Collections.singletonMap("part", Integer.MAX_VALUE), parts, "part", "%s"); assertThat(parts, is(empty())); } @Test public void extractAuthorPartString() { List<String> parts = new ArrayList<>(); underTest.extractAuthorPart(Collections.singletonMap("part", "value"), parts, "part", "%s"); assertThat(parts, contains("value")); }
### Question: ComposerPathUtils { public static String buildProviderPath(final Context context) { TokenMatcher.State state = context.getAttributes().require(TokenMatcher.State.class); Map<String, String> tokens = state.getTokens(); return buildProviderPath(tokens.get(VENDOR_TOKEN), tokens.get(PROJECT_TOKEN)); } private ComposerPathUtils(); static String getVendorToken(final Context context); static String getProjectToken(final Context context); static String getVersionToken(final Context context); static String buildZipballPath(final Context context); static String buildZipballPath(final String vendor, final String project, final String version); static String buildProviderPath(final Context context); static String buildProviderPath(final String vendor, final String project); }### Answer: @Test public void buildProviderPathFromTokens() { when(context.getAttributes()).thenReturn(contextAttributes); when(contextAttributes.require(TokenMatcher.State.class)).thenReturn(state); when(state.getTokens()).thenReturn(tokens); when(tokens.get(VENDOR_TOKEN)).thenReturn("testvendor"); when(tokens.get(PROJECT_TOKEN)).thenReturn("testproject"); assertThat(ComposerPathUtils.buildProviderPath(context), is("p/testvendor/testproject.json")); } @Test public void buildProviderPathFromValues() { assertThat(ComposerPathUtils.buildProviderPath("testvendor", "testproject"), is("p/testvendor/testproject.json")); }
### Question: ComposerHostedUploadHandler implements Handler { @Nonnull @Override public Response handle(@Nonnull final Context context) throws Exception { String vendor = getVendorToken(context); String project = getProjectToken(context); String version = getVersionToken(context); Request request = checkNotNull(context.getRequest()); Payload payload = checkNotNull(request.getPayload()); Repository repository = context.getRepository(); ComposerHostedFacet hostedFacet = repository.facet(ComposerHostedFacet.class); hostedFacet.upload(vendor, project, version, payload); return HttpResponses.ok(); } @Nonnull @Override Response handle(@Nonnull final Context context); }### Answer: @Test public void testHandle() throws Exception { when(repository.facet(ComposerHostedFacet.class)).thenReturn(composerHostedFacet); when(request.getPayload()).thenReturn(payload); when(context.getRepository()).thenReturn(repository); when(context.getAttributes()).thenReturn(attributes); when(context.getRequest()).thenReturn(request); when(attributes.require(TokenMatcher.State.class)).thenReturn(state); when(state.getTokens()).thenReturn(tokens); when(tokens.get(VENDOR_TOKEN)).thenReturn("testvendor"); when(tokens.get(PROJECT_TOKEN)).thenReturn("testproject"); when(tokens.get(VERSION_TOKEN)).thenReturn("testversion"); Response response = underTest.handle(context); assertThat(response.getStatus().getCode(), is(200)); assertThat(response.getPayload(), is(nullValue())); verify(composerHostedFacet).upload("testvendor", "testproject", "testversion", payload); }
### Question: ComposerProviderHandler implements Handler { @Nonnull @Override public Response handle(@Nonnull final Context context) throws Exception { Response response = context.proceed(); if (!Boolean.parseBoolean(context.getRequest().getAttributes().get(DO_NOT_REWRITE, String.class))) { if (response.getStatus().getCode() == HttpStatus.OK && response.getPayload() != null) { response = HttpResponses .ok(composerJsonProcessor.rewriteProviderJson(context.getRepository(), response.getPayload())); } } return response; } @Inject ComposerProviderHandler(final ComposerJsonProcessor composerJsonProcessor); @Nonnull @Override Response handle(@Nonnull final Context context); static final String DO_NOT_REWRITE; }### Answer: @Test public void handleWithRewriteDisabled() throws Exception { when(requestAttributes.get(DO_NOT_REWRITE, String.class)).thenReturn("true"); Response output = underTest.handle(context); assertThat(output, is(response)); verifyNoMoreInteractions(composerJsonProcessor); } @Test public void handleWithRewriteEnabled() throws Exception { Response output = underTest.handle(context); assertThat(output, is(not(response))); assertThat(output.getPayload(), is(rewrittenPayload)); verify(composerJsonProcessor).rewriteProviderJson(repository, payload); } @Test public void handleWithRewriteEnabledNotOK() throws Exception { when(status.getCode()).thenReturn(INTERNAL_SERVER_ERROR); Response output = underTest.handle(context); assertThat(output, is(response)); verifyNoMoreInteractions(composerJsonProcessor); } @Test public void handleWithRewriteEnabledNoPayload() throws Exception { when(response.getPayload()).thenReturn(null); Response output = underTest.handle(context); assertThat(output, is(response)); verifyNoMoreInteractions(composerJsonProcessor); }
### Question: ComposerHostedFacetImpl extends FacetSupport implements ComposerHostedFacet { @Override @TransactionalStoreBlob public void upload(final String vendor, final String project, final String version, final Payload payload) throws IOException { content().put(ComposerPathUtils.buildZipballPath(vendor, project, version), payload, AssetKind.ZIPBALL); } @Inject ComposerHostedFacetImpl(final ComposerJsonProcessor composerJsonProcessor); @Override @TransactionalStoreBlob void upload(final String vendor, final String project, final String version, final Payload payload); @Override Content getZipball(final String path); @Override @TransactionalTouchMetadata Content getPackagesJson(); @Override @TransactionalTouchMetadata Content getProviderJson(final String vendor, final String project); @Override @TransactionalStoreBlob void rebuildProviderJson(final String vendor, final String project); }### Answer: @Test public void testUpload() throws Exception { underTest.upload(VENDOR, PROJECT, VERSION, payload); verify(composerContentFacet).put(ZIPBALL_PATH, payload, ZIPBALL); }
### Question: ComposerHostedFacetImpl extends FacetSupport implements ComposerHostedFacet { @Override public Content getZipball(final String path) throws IOException { return content().get(path); } @Inject ComposerHostedFacetImpl(final ComposerJsonProcessor composerJsonProcessor); @Override @TransactionalStoreBlob void upload(final String vendor, final String project, final String version, final Payload payload); @Override Content getZipball(final String path); @Override @TransactionalTouchMetadata Content getPackagesJson(); @Override @TransactionalTouchMetadata Content getProviderJson(final String vendor, final String project); @Override @TransactionalStoreBlob void rebuildProviderJson(final String vendor, final String project); }### Answer: @Test public void testGetZipball() throws Exception { when(composerContentFacet.get(ZIPBALL_PATH)).thenReturn(content); assertThat(underTest.getZipball(ZIPBALL_PATH), is(content)); }
### Question: ComposerHostedFacetImpl extends FacetSupport implements ComposerHostedFacet { @Override @TransactionalTouchMetadata public Content getPackagesJson() throws IOException { StorageTx tx = UnitOfWork.currentTx(); return composerJsonProcessor .generatePackagesFromComponents(getRepository(), tx.browseComponents(tx.findBucket(getRepository()))); } @Inject ComposerHostedFacetImpl(final ComposerJsonProcessor composerJsonProcessor); @Override @TransactionalStoreBlob void upload(final String vendor, final String project, final String version, final Payload payload); @Override Content getZipball(final String path); @Override @TransactionalTouchMetadata Content getPackagesJson(); @Override @TransactionalTouchMetadata Content getProviderJson(final String vendor, final String project); @Override @TransactionalStoreBlob void rebuildProviderJson(final String vendor, final String project); }### Answer: @Test public void testGetPackagesJson() throws Exception { when(tx.browseComponents(bucket)).thenReturn(components); when(composerJsonProcessor.generatePackagesFromComponents(repository, components)).thenReturn(content); assertThat(underTest.getPackagesJson(), is(content)); }
### Question: ComposerHostedFacetImpl extends FacetSupport implements ComposerHostedFacet { @Override @TransactionalTouchMetadata public Content getProviderJson(final String vendor, final String project) throws IOException { return content().get(ComposerPathUtils.buildProviderPath(vendor, project)); } @Inject ComposerHostedFacetImpl(final ComposerJsonProcessor composerJsonProcessor); @Override @TransactionalStoreBlob void upload(final String vendor, final String project, final String version, final Payload payload); @Override Content getZipball(final String path); @Override @TransactionalTouchMetadata Content getPackagesJson(); @Override @TransactionalTouchMetadata Content getProviderJson(final String vendor, final String project); @Override @TransactionalStoreBlob void rebuildProviderJson(final String vendor, final String project); }### Answer: @Test public void testGetProviderJson() throws Exception { when(composerContentFacet.get(PROVIDER_PATH)).thenReturn(content); assertThat(underTest.getProviderJson(VENDOR, PROJECT), is(content)); }
### Question: ComposerHostedFacetImpl extends FacetSupport implements ComposerHostedFacet { @VisibleForTesting protected Query buildQuery(final String vendor, final String project) { return Query.builder().where(P_GROUP).eq(vendor).and(P_NAME).eq(project).build(); } @Inject ComposerHostedFacetImpl(final ComposerJsonProcessor composerJsonProcessor); @Override @TransactionalStoreBlob void upload(final String vendor, final String project, final String version, final Payload payload); @Override Content getZipball(final String path); @Override @TransactionalTouchMetadata Content getPackagesJson(); @Override @TransactionalTouchMetadata Content getProviderJson(final String vendor, final String project); @Override @TransactionalStoreBlob void rebuildProviderJson(final String vendor, final String project); }### Answer: @Test public void testBuildQuery() throws Exception { Query result = underTest.buildQuery(VENDOR, PROJECT); assertThat(result.getWhere(), is("group = :p0 AND name = :p1")); assertThat(result.getParameters(), hasEntry("p0", VENDOR)); assertThat(result.getParameters(), hasEntry("p1", PROJECT)); }
### Question: ComposerContentFacetImpl extends FacetSupport implements ComposerContentFacet { @Nullable @Override @TransactionalTouchBlob public Content get(final String path) throws IOException { StorageTx tx = UnitOfWork.currentTx(); final Asset asset = findAsset(tx, path); if (asset == null) { return null; } if (asset.markAsDownloaded()) { tx.saveAsset(asset); } final Blob blob = tx.requireBlob(asset.requireBlobRef()); return toContent(asset, blob); } @Inject ComposerContentFacetImpl(@Named(ComposerFormat.NAME) final Format format, final ComposerFormatAttributesExtractor composerFormatAttributesExtractor); @Nullable @Override @TransactionalTouchBlob Content get(final String path); @Override Content put(final String path, final Payload payload, final AssetKind assetKind); @Override @TransactionalTouchMetadata void setCacheInfo(final String path, final Content content, final CacheInfo cacheInfo); @TransactionalStoreMetadata Asset getOrCreateAsset(final String path); @TransactionalStoreMetadata Asset getOrCreateAsset(final String path, final String group, final String name, final String version); }### Answer: @Test public void getAssetNotFound() throws Exception { assertThat(underTest.get("path"), is(nullValue())); }
### Question: ComposerJsonProcessor { public Content generatePackagesFromList(final Repository repository, final Payload payload) throws IOException { Map<String, Object> listJson = parseJson(payload); return buildPackagesJson(repository, new LinkedHashSet<>((Collection<String>) listJson.get(PACKAGE_NAMES_KEY))); } @Inject ComposerJsonProcessor(final ComposerJsonExtractor composerJsonExtractor); Content generatePackagesFromList(final Repository repository, final Payload payload); Content generatePackagesFromComponents(final Repository repository, final Iterable<Component> components); Payload rewriteProviderJson(final Repository repository, final Payload payload); Content buildProviderJson(final Repository repository, final StorageTx storageTx, final Iterable<Component> components); Content mergePackagesJson(final Repository repository, final List<Payload> payloads); Content mergeProviderJson(final Repository repository, final List<Payload> payloads, final DateTime now); String getDistUrl(final String vendor, final String project, final String version, final Payload payload); }### Answer: @Test public void generatePackagesFromList() throws Exception { String listJson = readStreamToString(getClass().getResourceAsStream("generatePackagesFromList.list.json")); String packagesJson = readStreamToString(getClass().getResourceAsStream("generatePackagesFromList.packages.json")); when(repository.getUrl()).thenReturn("http: when(payload1.openInputStream()).thenReturn(new ByteArrayInputStream(listJson.getBytes(UTF_8))); ComposerJsonProcessor underTest = new ComposerJsonProcessor(composerJsonExtractor); Content output = underTest.generatePackagesFromList(repository, payload1); assertEquals(packagesJson, readStreamToString(output.openInputStream()), true); }
### Question: ComposerJsonProcessor { public Content generatePackagesFromComponents(final Repository repository, final Iterable<Component> components) throws IOException { return buildPackagesJson(repository, StreamSupport.stream(components.spliterator(), false) .map(component -> component.group() + "/" + component.name()).collect(Collectors.toSet())); } @Inject ComposerJsonProcessor(final ComposerJsonExtractor composerJsonExtractor); Content generatePackagesFromList(final Repository repository, final Payload payload); Content generatePackagesFromComponents(final Repository repository, final Iterable<Component> components); Payload rewriteProviderJson(final Repository repository, final Payload payload); Content buildProviderJson(final Repository repository, final StorageTx storageTx, final Iterable<Component> components); Content mergePackagesJson(final Repository repository, final List<Payload> payloads); Content mergeProviderJson(final Repository repository, final List<Payload> payloads, final DateTime now); String getDistUrl(final String vendor, final String project, final String version, final Payload payload); }### Answer: @Test public void generatePackagesFromComponents() throws Exception { String packagesJson = readStreamToString(getClass().getResourceAsStream("generatePackagesFromComponents.json")); when(repository.getUrl()).thenReturn("http: when(component1.group()).thenReturn("vendor1"); when(component1.name()).thenReturn("project1"); when(component1.version()).thenReturn("version1"); when(component2.group()).thenReturn("vendor2"); when(component2.name()).thenReturn("project2"); when(component2.version()).thenReturn("version2"); when(component3.group()).thenReturn("vendor1"); when(component3.name()).thenReturn("project1"); when(component3.version()).thenReturn("version2"); ComposerJsonProcessor underTest = new ComposerJsonProcessor(composerJsonExtractor); Content output = underTest.generatePackagesFromComponents(repository, asList(component1, component2, component3)); assertEquals(packagesJson, readStreamToString(output.openInputStream()), true); }
### Question: ComposerJsonProcessor { public Content mergePackagesJson(final Repository repository, final List<Payload> payloads) throws IOException { Set<String> names = new HashSet<>(); for (Payload payload : payloads) { Map<String, Object> json = parseJson(payload); Map<String, Object> providers = (Map<String, Object>) json.get(PROVIDERS_KEY); names.addAll(providers.keySet()); } return buildPackagesJson(repository, names); } @Inject ComposerJsonProcessor(final ComposerJsonExtractor composerJsonExtractor); Content generatePackagesFromList(final Repository repository, final Payload payload); Content generatePackagesFromComponents(final Repository repository, final Iterable<Component> components); Payload rewriteProviderJson(final Repository repository, final Payload payload); Content buildProviderJson(final Repository repository, final StorageTx storageTx, final Iterable<Component> components); Content mergePackagesJson(final Repository repository, final List<Payload> payloads); Content mergeProviderJson(final Repository repository, final List<Payload> payloads, final DateTime now); String getDistUrl(final String vendor, final String project, final String version, final Payload payload); }### Answer: @Test public void mergePackagesJson() throws Exception { String inputJson1 = readStreamToString(getClass().getResourceAsStream("mergePackagesJson.input1.json")); String inputJson2 = readStreamToString(getClass().getResourceAsStream("mergePackagesJson.input2.json")); String outputJson = readStreamToString(getClass().getResourceAsStream("mergePackagesJson.output.json")); when(repository.getUrl()).thenReturn("http: when(payload1.openInputStream()).thenReturn(new ByteArrayInputStream(inputJson1.getBytes(UTF_8))); when(payload2.openInputStream()).thenReturn(new ByteArrayInputStream(inputJson2.getBytes(UTF_8))); ComposerJsonProcessor underTest = new ComposerJsonProcessor(composerJsonExtractor); Payload output = underTest.mergePackagesJson(repository, Arrays.asList(payload1, payload2)); assertEquals(outputJson, readStreamToString(output.openInputStream()), true); }
### Question: ComposerJsonProcessor { public String getDistUrl(final String vendor, final String project, final String version, final Payload payload) throws IOException { String vendorAndProject = String.format(VENDOR_AND_PROJECT, vendor, project); Map<String, Object> json = parseJson(payload); Map<String, Object> packagesMap = (Map<String, Object>) json.get(PACKAGES_KEY); Map<String, Object> packageInfo = (Map<String, Object>) packagesMap.get(vendorAndProject); Map<String, Object> versionInfo = (Map<String, Object>) packageInfo.get(version); Map<String, Object> distInfo = (Map<String, Object>) versionInfo.get(DIST_KEY); return (String) distInfo.get(URL_KEY); } @Inject ComposerJsonProcessor(final ComposerJsonExtractor composerJsonExtractor); Content generatePackagesFromList(final Repository repository, final Payload payload); Content generatePackagesFromComponents(final Repository repository, final Iterable<Component> components); Payload rewriteProviderJson(final Repository repository, final Payload payload); Content buildProviderJson(final Repository repository, final StorageTx storageTx, final Iterable<Component> components); Content mergePackagesJson(final Repository repository, final List<Payload> payloads); Content mergeProviderJson(final Repository repository, final List<Payload> payloads, final DateTime now); String getDistUrl(final String vendor, final String project, final String version, final Payload payload); }### Answer: @Test public void getDistUrl() throws Exception { String inputJson = readStreamToString(getClass().getResourceAsStream("getDistUrl.json")); when(payload1.openInputStream()).thenReturn(new ByteArrayInputStream(inputJson.getBytes(UTF_8))); ComposerJsonProcessor underTest = new ComposerJsonProcessor(composerJsonExtractor); String distUrl = underTest.getDistUrl("vendor1", "project1", "2.0.0", payload1); assertThat(distUrl, is("https: }
### Question: PeerApiImpl implements PeerApi { @Override public List<String> getAllActivePeer() { return peerDialer.getActivePeerList(); } @Autowired PeerApiImpl(PeerDialer peerDialer); @Override List<String> getAllActivePeer(); }### Answer: @Test public void getAllActivePeerTest() { try { assertThat(PEER_API.getAllActivePeer()).isNotNull(); } catch (Exception exception) { log.debug("getAllActivePeerTest :: exception : " + exception); } }
### Question: PeerBucket { public synchronized void bump(Peer peer) { if (peers.contains(peer)) { moveToFront(peers, peer); } } PeerBucket(int depth); int getPeersCount(); synchronized void bump(Peer peer); }### Answer: @Test public void testBump() { Peer peer3 = Peer.valueOf("ynode: bucket.addPeer(peer1); bucket.addPeer(peer2); bucket.addPeer(peer3); bucket.bump(peer3); assert bucket.getPeersCount() == 3; assertTrue(getLastPeer(peer2)); }
### Question: PeerBucket { synchronized void addPeer(Peer peer) { if (!bumpOrAdd(peer)) { addReplacement(peer); } } PeerBucket(int depth); int getPeersCount(); synchronized void bump(Peer peer); }### Answer: @Test public void testAddPeer() { KademliaOptions.BUCKET_SIZE = 5; addPeerToBucket(32920, 32930); assertEquals(5, bucket.getPeersCount()); assertEquals(5, bucket.getReplacements().size()); assertTrue(getLastPeer(Peer.valueOf("ynode: Peer lastPeerOfReplacements = bucket.getReplacements() .stream() .skip(bucket.getReplacements().size() - 1) .findFirst() .orElse(null); assertEquals(lastPeerOfReplacements, Peer.valueOf("ynode: }
### Question: PeerBucket { synchronized Peer replace(Peer last) { if (peers.isEmpty() || getLastPeer() != last) { return null; } if (replacements.isEmpty()) { dropPeer(last); return null; } Peer peerToBeReplaced = lastPeerOf(replacements); deleteReplacement(peerToBeReplaced); dropPeer(last); addPeer(peerToBeReplaced); return peerToBeReplaced; } PeerBucket(int depth); int getPeersCount(); synchronized void bump(Peer peer); }### Answer: @Test public void testReplace() { KademliaOptions.BUCKET_SIZE = 5; addPeerToBucket(32920, 32925); Peer randomPeer = Peer.valueOf("ynode: assertNull(bucket.replace(randomPeer)); assertEquals(5, bucket.getPeersCount()); assertTrue(getLastPeer(Peer.valueOf("ynode: assertNull(bucket.replace(bucket.getLastPeer())); assertEquals(4, bucket.getPeersCount()); assertTrue(getLastPeer(Peer.valueOf("ynode: addPeerToBucket(32924, 32930); assertEquals(5, bucket.getReplacements().size()); assertEquals(bucket.replace(bucket.getLastPeer()), Peer.valueOf("ynode: printList(bucket.getReplacements(), "replace"); printList(bucket.getPeers(), "p"); assertEquals(4, bucket.getReplacements().size()); assertTrue(getLastPeer(Peer.valueOf("ynode: }
### Question: PeerId { public static PeerId of(byte[] hash) { return new PeerId(hash); } private PeerId(Sha3Hash hash); private PeerId(byte[] bytes); byte[] getBytes(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static PeerId of(byte[] hash); static PeerId of(String ynodeUri); }### Answer: @Test public void of() { PeerId peerId1 = PeerId.of(ynodeUri1); byte[] b = peerId1.getBytes(); PeerId peerId2 = PeerId.of(b); Assert.assertEquals(peerId1, peerId2); }
### Question: DistanceComparator implements Comparator<Peer> { @Override public int compare(Peer p1, Peer p2) { int d1 = p1.getPeerId().distanceTo(targetId); int d2 = p2.getPeerId().distanceTo(targetId); return Integer.compare(d1, d2); } DistanceComparator(byte[] targetId); @Override int compare(Peer p1, Peer p2); }### Answer: @Test public void compareTest() { DistanceComparator distanceComparator = new DistanceComparator(OWNER.getPeerId().getBytes()); Peer p1 = Peer.valueOf("ynode: Peer p2 = Peer.valueOf("ynode: int shortDistance = OWNER.getPeerId().distanceTo(p1.getPeerId().getBytes()); int longDistance = OWNER.getPeerId().distanceTo(p2.getPeerId().getBytes()); assert shortDistance < longDistance; assert distanceComparator.compare(p1, p2) < 0; ArrayList<Peer> peerArrayList = new ArrayList<>(); peerArrayList.add(p2); peerArrayList.add(p1); peerArrayList.sort(distanceComparator); assert peerArrayList.get(0).equals(p1); Assert.assertEquals(shortDistance,peerArrayList.get(0).getPeerId().distanceTo(OWNER.getPeerId().getBytes())); }
### Question: BlockChainStoreBuilder { public ConsensusBlockStore buildBlockStore() { DbSource dbSource = getDbSource(branchId + "/blocks"); return blockStoreFactory.create(consensusAlgorithm, dbSource); } private BlockChainStoreBuilder(BranchId branchId); BlockChainStoreBuilder withProductionMode(Boolean isProductionMode); BlockChainStoreBuilder withDataBasePath(String databasePath); BlockChainStoreBuilder setBlockStoreFactory(BlockStoreFactory blockStoreFactory); BlockChainStoreBuilder setConsensusAlgorithm(String consensusAlgorithm); static BlockChainStoreBuilder newBuilder(BranchId branchId); ConsensusBlockStore buildBlockStore(); BlockChainStore build(); }### Answer: @Test public void buildBlockStore() { ConsensusBlock block = BlockChainTestUtils.genesisBlock(); ConsensusBlockStore store = builder.setBlockStoreFactory(PbftBlockStoreMock::new).buildBlockStore(); store.put(block.getHash(), block); assertThat(store.contains(block.getHash())).isTrue(); assertThat(store.get(block.getHash())).isEqualTo(block); }
### Question: TransactionStore implements ReadWriterStore<Sha3Hash, Transaction> { @Override public void put(Sha3Hash key, Transaction tx) { lock.lock(); try { if (!containsUnlock(key)) { pendingPool.put(key, tx); if (pendingPool.containsKey(key)) { pendingKeys.add(key); } else { log.debug("unconfirmedTxs size={}, ignore key={}", pendingKeys.size(), key); } } } catch (Exception e) { log.warn("put() is failed. {} {}", e.getMessage(), key.toString()); } finally { lock.unlock(); } } TransactionStore(DbSource<byte[], byte[]> db); TransactionStore(DbSource<byte[], byte[]> db, int cacheSize); Collection<Transaction> getRecentTxs(); @Override boolean contains(Sha3Hash key); @Override void close(); @Override void put(Sha3Hash key, Transaction tx); void addTransaction(Transaction tx); @Override Transaction get(Sha3Hash key); void batch(Set<Sha3Hash> keys); List<Transaction> getUnconfirmedTxsWithLimit(long limit); Collection<Transaction> getUnconfirmedTxs(); int getUnconfirmedTxsSize(); void flush(Set<Sha3Hash> keys); void updateCache(Block block); }### Answer: @Test public void TEST() { Cache<String, Integer> pendingPool = CacheManagerBuilder .newCacheManagerBuilder().build(true) .createCache("txPool", CacheConfigurationBuilder .newCacheConfigurationBuilder(String.class, Integer.class, ResourcePoolsBuilder.heap(Long.MAX_VALUE))); Set<String> pendingKeys = new LinkedHashSet<>(); pendingPool.put("1", 1); pendingKeys.add("1"); pendingPool.put("2", 2); pendingKeys.add("2"); pendingPool.put("3", 3); pendingKeys.add("3"); ArrayList<Integer> haha = new ArrayList<>(pendingPool.getAll(pendingKeys).values()); }
### Question: PeerStore implements ReadWriterStore<PeerId, Peer> { public void overwrite(List<Peer> peerList) { lock.lock(); try { for (int i = 1; i <= peerSize; i++) { byte[] indexKey = getIndexKey(i); byte[] key = db.get(indexKey); if (key != null) { db.delete(key); } } peerSize = 0L; peerList.forEach(peer -> put(peer.getPeerId(), peer)); } finally { lock.unlock(); } } PeerStore(DbSource<byte[], byte[]> dbSource); @Override void put(PeerId key, Peer value); @Override Peer get(PeerId key); @Override boolean contains(PeerId key); void overwrite(List<Peer> peerList); @Override void close(); void remove(PeerId key); List<String> getAll(); long size(); }### Answer: @Test public void overwrite() { Peer p1 = Peer.valueOf("ynode: Peer p2 = Peer.valueOf("ynode: peerStore.put(p1.getPeerId(), p1); peerStore.put(p2.getPeerId(), p2); assertEquals(2, peerStore.getAll().size()); assertTrue(peerStore.contains(p1.getPeerId())); assertTrue(peerStore.contains(p2.getPeerId())); Peer p3 = Peer.valueOf("ynode: Peer p4 = Peer.valueOf("ynode: Peer p5 = Peer.valueOf("ynode: List<Peer> peerList = new ArrayList<>(); peerList.add(p3); peerList.add(p4); peerList.add(p5); peerStore.overwrite(peerList); assertEquals(3, peerStore.getAll().size()); assertFalse(peerStore.contains(p1.getPeerId())); assertFalse(peerStore.contains(p2.getPeerId())); assertTrue(peerStore.contains(p3.getPeerId())); assertTrue(peerStore.contains(p4.getPeerId())); assertTrue(peerStore.contains(p5.getPeerId())); }
### Question: StoreBuilder { public PeerStore buildPeerStore() { return new PeerStore(getDbSource(branchId + "/peers")); } StoreBuilder setConfig(DefaultConfig config); DefaultConfig getConfig(); StoreBuilder setBranchId(BranchId branchId); PeerStore buildPeerStore(); static StoreBuilder newBuilder(); }### Answer: @Test public void buildPeerStore() { Peer peer = Peer.valueOf("ynode: PeerStore store = builder.buildPeerStore(); store.put(peer.getPeerId(), peer); assertThat(store.contains(peer.getPeerId())).isTrue(); assertThat(store.get(peer.getPeerId())).isEqualTo(peer); }
### Question: LogApiImpl implements LogApi { @Override public List<Log> getLogs(String branchId, long start, long offset) { return branchGroup.getBranch(BranchId.of(branchId)).getContractManager().getLogs(start, offset); } @Autowired LogApiImpl(BranchGroup branchGroup); @Override Log getLog(String branchId, long index); @Override List<Log> getLogs(String branchId, long start, long offset); @Override List<Log> getLogs(String branchId, String regex, long start, long offset); @Override long curIndex(String branchId); }### Answer: @Test public void getLogsByRegexJsonRpcTest() { try { LOG_API.getLogs(branchId, "\\W*(Total)\\W*", 0, 100); } catch (Exception e) { log.debug("getLogsTest :: ERR => {}", e.getMessage()); } } @Ignore @Test public void getLogsByRegexTest() { List<Log> res = logApi.getLogs(branchId, "\\W*(Total)\\W*", 0, 100); assertEquals(1, res.size()); res = logApi.getLogs(branchId, "\\W*(TTotal)\\W*", 0, 100); assertEquals(0, res.size()); } @Test public void getLogsJsonRpcTest() { try { LOG_API.getLogs(branchId, 0, 9); } catch (Exception e) { log.debug("getLogsTest :: ERR => {}", e.getMessage()); } }
### Question: BlockServiceConsumer implements BlockConsumer<T> { @Override public void broadcastBlock(ConsensusBlock<T> block) { try { BranchId branchId = block.getBranchId(); long nextIndex = branchGroup.getLastIndex(branchId) + 1; long receivedIndex = block.getIndex(); if (receivedIndex == nextIndex) { branchGroup.addBlock(block, true); } else { log.trace("Received blockIndex({}) is not nextBlockIndex({}).", block.getIndex(), nextIndex); } } catch (Exception e) { log.debug("BroadcastBlock() is failed. {}", e.getMessage()); } } BlockServiceConsumer(BranchGroup branchGroup); @Override void setListener(CatchUpSyncEventListener listener); @Override List<ConsensusBlock<T>> syncBlock(BranchId branchId, long offset, long limit); @Override void broadcastBlock(ConsensusBlock<T> block); }### Answer: @Test public void broadcastBlock() { assertEquals(0, branchGroup.getBranch(branchId).getBlockChainManager().getLastIndex()); ConsensusBlock<PbftProto.PbftBlock> nextBlock = BlockChainTestUtils.createNextBlock(); blockServiceConsumer.broadcastBlock(nextBlock); blockServiceConsumer.broadcastBlock(nextBlock); assertEquals(1, branchGroup.getBranch(branchId).getBlockChainManager().getLastIndex()); }
### Question: BootStrapNode implements BootStrap { @Override public void bootstrapping() { peerNetwork.init(); syncManager.fullSync(); } @Override void bootstrapping(); void setPeerNetwork(PeerNetwork peerNetwork); void setSyncManager(SyncManager syncManager); }### Answer: @Test public void bootstrappingTest() { bootstrapping(); Assert.assertTrue(BlockChainSyncManagerMock.nodeStatus.isUpStatus()); }
### Question: BranchLoader { public List<GenesisBlock> getGenesisBlockList() { return genesisBlockList; } BranchLoader(String branchPath); Optional<GenesisBlock> getGenesisBlock(BranchId branchId); List<GenesisBlock> getGenesisBlockList(); static final String BRANCH_FILE; }### Answer: @Test public void getBranchInfo() { String branchPath = new DefaultConfig().getBranchPath(); BranchLoader loader = new BranchLoader(branchPath); Assert.assertNotNull(loader.getGenesisBlockList()); }
### Question: BranchLoader { boolean saveBranch(Branch branch) { File branchDir = loadBranchDirectory(branch.getBranchId()); if (!branchDir.exists()) { branchDir.mkdir(); File branchFile = new File(branchDir, BRANCH_FILE); try (FileOutputStream outputStream = new FileOutputStream(branchFile)) { byte[] branchJson = branch.getJson().toString().getBytes(); outputStream.write(branchJson); return true; } catch (IOException e) { log.error(e.getMessage()); } } return false; } BranchLoader(String branchPath); Optional<GenesisBlock> getGenesisBlock(BranchId branchId); List<GenesisBlock> getGenesisBlockList(); static final String BRANCH_FILE; }### Answer: @Test public void saveBranchTest() throws IOException { String branchPath = new DefaultConfig().getBranchPath(); BranchLoader loader = new BranchLoader(branchPath); Assert.assertTrue(loader.saveBranch(branch)); Path targetBranch = Paths.get(branchPath, branch.getBranchId().toString(), BranchLoader.BRANCH_FILE); String reloadBranch = FileUtil.readFileToString(targetBranch.toFile(), FileUtil.DEFAULT_CHARSET); JsonObject branchJson = new JsonParser().parse(reloadBranch).getAsJsonObject(); Assert.assertEquals(Branch.of(branchJson).getBranchId(), branch.getBranchId()); }
### Question: TransactionBody { public TransactionBody(String body) { this.body = JsonUtil.parseJsonObject(body); } TransactionBody(String body); TransactionBody(JsonObject body); JsonObject getBody(); long getLength(); byte[] getHash(); byte[] toBinary(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testTransactionBody() { JsonObject jsonObject = new JsonObject(); jsonObject.addProperty("test", "00"); log.debug("JsonObject=" + jsonObject.toString()); log.debug("JsonObjectSize=" + jsonObject.size()); log.debug("JsonObjectStringSize=" + jsonObject.toString().length()); TransactionBody txBody1 = new TransactionBody(jsonObject); log.debug("txBody={}", txBody1.getBody()); assertEquals(jsonObject.toString(), txBody1.getBody().toString()); log.debug("txBody length={}", txBody1.getLength()); assertEquals(txBody1.toBinary().length, txBody1.getLength()); log.debug("txBody Binary={}", Hex.toHexString(txBody1.toBinary())); assertArrayEquals(SerializationUtil.serializeString(txBody1.toString()), txBody1.toBinary()); log.debug("txBody count={}", txBody1.getCount()); assertEquals(1, txBody1.getCount()); TransactionBody txBody2 = new TransactionBody(txBody1.getBody()); assertEquals(txBody1, txBody2); assertEquals(txBody1.toString(), txBody2.toString()); TransactionBody txBody3 = new TransactionBody(txBody1.toString()); log.debug("txBody1 String={}", txBody1); log.debug("txBody3 String={}", txBody3); assertEquals(txBody1.toString(), txBody3.toString()); byte[] data = SerializationUtil.serializeString(jsonObject.toString()); TransactionBody txBody4 = new TransactionBody(SerializationUtil.deserializeString(data)); log.debug("txBody1 String={}", txBody1); log.debug("txBody4 String={}", txBody4); assertEquals(txBody1, txBody4); }
### Question: LogApiImpl implements LogApi { @Override public long curIndex(String branchId) { try { return branchGroup.getBranch(BranchId.of(branchId)).getContractManager().getCurLogIndex(); } catch (NullPointerException ne){ log.debug("CurIndex Exception: {}", BRANCH_NOT_FOUND); return 0; } catch (Exception e) { log.debug("CurIndex Exception : {}", e.getMessage()); return 0; } } @Autowired LogApiImpl(BranchGroup branchGroup); @Override Log getLog(String branchId, long index); @Override List<Log> getLogs(String branchId, long start, long offset); @Override List<Log> getLogs(String branchId, String regex, long start, long offset); @Override long curIndex(String branchId); }### Answer: @Test public void curIndexJsonRpcTest() { try { long res = LOG_API.curIndex(branchId); } catch (Exception e) { log.debug("curIndexTest :: ERR => {}", e.getMessage()); } }
### Question: BranchGroup { public void addBranch(BlockChain blockChain) { if (blockChain == null) { return; } BranchId branchId = blockChain.getBranchId(); if (branches.containsKey(branchId)) { throw new DuplicatedException(branchId.toString() + " duplicated"); } branches.put(branchId, blockChain); } void addBranch(BlockChain blockChain); BlockChain getBranch(BranchId branchId); boolean isFullSynced(BranchId branchId); int verify(BranchId branchId, String contractVersion); Collection<BlockChain> getAllBranch(); Map<String, List<String>> addTransaction(Transaction tx); long getLastIndex(BranchId branchId); boolean isBranchExist(BranchId branchId); Collection<Transaction> getRecentTxs(BranchId branchId); Transaction getTxByHash(BranchId branchId, String id); void addBlock(ConsensusBlock block, boolean broadcast); ConsensusBlock getBlockByIndex(BranchId branchId, long index); ConsensusBlock getBlockByHash(BranchId branchId, String hash); Receipt getReceipt(BranchId branchId, String key); List<Transaction> getUnconfirmedTxs(BranchId branchId); Object query(BranchId branchId, String contractVersion, String method, JsonObject params); }### Answer: @Test(expected = DuplicatedException.class) public void addExistedBranch() { BlockChain exist = BlockChainTestUtils.createBlockChain(false); branchGroup.addBranch(exist); }
### Question: LogIndexer { public String get(long logIndex) { return logStore.get(logIndex); } LogIndexer(LogStore logStore, ReceiptStore receiptStore); void put(String txId, int size); String get(long logIndex); Log getLog(long logIndex); List<Log> getLogs(long from, long offset); long curIndex(); boolean contains(long logIndex); void close(); }### Answer: @Test public void getValueTest() { for (int i = 0; i < 10; i++) { assertEquals(String.format(keyFormat, txHashes.get(i), 9), logIndexer.get(10 * i + 9)); assertEquals(String.format(keyFormat, txHashes.get(i), 0), logIndexer.get(10 * i)); } }
### Question: LogIndexer { public Log getLog(long logIndex) { if (logIndex < 0 || logIndex > curIndex()) { return Log.createBy(logIndex, "", "Log not exists"); } String val = get(logIndex); int separator = val.indexOf(keySeparator); String txId = val.substring(0, separator); int indexOfReceipt = Integer.parseInt(val.substring(separator + 1)); String log = receiptStore.get(txId).getLog().get(indexOfReceipt); return Log.createBy(logIndex, txId, log); } LogIndexer(LogStore logStore, ReceiptStore receiptStore); void put(String txId, int size); String get(long logIndex); Log getLog(long logIndex); List<Log> getLogs(long from, long offset); long curIndex(); boolean contains(long logIndex); void close(); }### Answer: @Test public void getLogTest() { for (int i = 0; i < 100; i++) { assertEquals(String.format(logFormat, i % 10), logIndexer.getLog(i).getMsg()); } }
### Question: LogIndexer { public List<Log> getLogs(long from, long offset) { long start = from < 0 ? 0 : from; long end = start + offset > curIndex() ? curIndex() : start + offset; return LongStream.rangeClosed(start, end).mapToObj(this::getLog).collect(Collectors.toList()); } LogIndexer(LogStore logStore, ReceiptStore receiptStore); void put(String txId, int size); String get(long logIndex); Log getLog(long logIndex); List<Log> getLogs(long from, long offset); long curIndex(); boolean contains(long logIndex); void close(); }### Answer: @Test public void getLogsTest() { int i = 0; for (Log log : logIndexer.getLogs(0, 9)) { assertEquals(String.format(logFormat, i++), log.getMsg()); } }
### Question: ContractChannelCoupler implements ContractChannel { public void setContract(Map<String, Object> serviceMap, ContractCache cache) { this.serviceMap = serviceMap; this.cache = cache; } void setContract(Map<String, Object> serviceMap, ContractCache cache); @Override JsonObject call(String contractVersion, ContractMethodType type, String methodName, JsonObject params); }### Answer: @Test public void callMethodTest() { ContractChannelCoupler coupler = new ContractChannelCoupler(); coupler.setContract(contractMap, cache); contractMap.values().stream().forEach(c -> { TestContract s = (TestContract)c; s.channel = coupler; }); TestContract t = (TestContract) contractMap.get("TEST2"); t.callContractChannelInvoke("TEST1", "callMethod"); t.callContractChannelQuery("TEST1","yesmanQuery"); } @Test public void callChnnelMethodTest() { ContractChannelCoupler coupler = new ContractChannelCoupler(); coupler.setContract(contractMap, cache); contractMap.values().stream().forEach(c -> { TestContract s = (TestContract)c; s.channel = coupler; }); TestContract t = (TestContract) contractMap.get("TEST2"); t.callContractChnnelMethod("TEST1", "transferChannel"); }
### Question: PrepareBlockchain { public File loadContractFile(ContractVersion version) { File contractFile = new File(String.format("%s/%s.jar", contractPath, version)); if (!(contractFile.exists() && contractFile.canRead())) { log.error("Contract {} is not exists", version); return null; } return contractFile; } PrepareBlockchain(String contractPath); File loadContractFile(ContractVersion version); boolean verifyContractFile(File contractFile, ContractVersion contractVersion); }### Answer: @Test @Ignore public void loadContractFile() { PrepareBlockchain pb = new PrepareBlockchain(new DefaultConfig().getContractPath()); ContractVersion version = ContractVersion.of("74df17611373672371cb3872e8a5d4a2e8733fb1"); File f = pb.loadContractFile(version); boolean verify = pb.verifyContractFile(f, version); assert verify == true; }
### Question: TransactionApiImpl implements TransactionApi { @Override public int getTransactionCountByBlockHash(String branchId, String blockId) { ConsensusBlock block = branchGroup.getBlockByHash(BranchId.of(branchId), blockId); return block.getBody().getCount(); } @Autowired TransactionApiImpl(BranchGroup branchGroup); @Override int getTransactionCountByBlockHash(String branchId, String blockId); @Override int getTransactionCountByBlockNumber(String branchId, long blockNumber); @Override TransactionDto getTransactionByHash(String branchId, String txId); @Override TransactionDto getTransactionByBlockHash(String branchId, String blockId, int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, long blockNumber, int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, String tag, int txIndexPosition); @Override TransactionResponseDto sendTransaction(TransactionDto tx); @Override TransactionResponseDto sendRawTransaction(byte[] bytes); @Override int newPendingTransactionFilter(String branchId); @Override List<String> getPendingTransactionList(String branchId); @Override int getPendingTransactionCount(String branchId); @Override TransactionReceiptDto getTransactionReceipt(String branchId, String txId); @Override String getRawTransaction(String branchId, String txId); @Override String getRawTransactionHeader(String branchId, String txId); }### Answer: @Test public void getBlockTransactionCountByHashTest() { assertThat(txApi.getTransactionCountByBlockHash(yggdrashBranch, testBlockHash)) .isNotZero(); }