src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
ServiceConfiguration implements Configuration { @Override public Properties getAsProperties() { String configuration = getServiceConfigurationInFormat(Format.PROPERTIES); Properties properties = new Properties(); try { properties.load(new StringReader(configuration)); } catch (IOException e) { throw new IllegalArgumentException("Error reading properties configuration", e); } return properties; } ServiceConfiguration(byte[] configuration); @Override MessageT getAsMessage(Class<MessageT> parametersType); @Override Format getConfigurationFormat(); @Override String getAsString(); @Override T getAsJson(Class<T> configType); @Override Properties getAsProperties(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); } | @Test void getAsProperties() { byte[] configuration = Service.ServiceConfiguration.newBuilder() .setFormat(Format.PROPERTIES) .setValue("foo=foo\nbar=bar") .build() .toByteArray(); ServiceConfiguration serviceConfiguration = new ServiceConfiguration(configuration); Properties properties = serviceConfiguration.getAsProperties(); assertThat(properties).contains(entry("foo", "foo"), entry("bar", "bar")); } |
TransactionExtractor { @VisibleForTesting static Map<Integer, Method> findTransactionMethods(Class<?> serviceClass) { Map<Integer, Method> transactionMethods = new HashMap<>(); while (serviceClass != Object.class) { Method[] classMethods = serviceClass.getDeclaredMethods(); for (Method method : classMethods) { if (method.isAnnotationPresent(Transaction.class)) { Transaction annotation = method.getAnnotation(Transaction.class); int transactionId = annotation.value(); checkDuplicates(transactionMethods, transactionId, serviceClass, method); transactionMethods.put(transactionId, method); } } serviceClass = serviceClass.getSuperclass(); } return transactionMethods; } private TransactionExtractor(); } | @Test void findTransactionMethodsValidService() throws Exception { Map<Integer, Method> transactions = TransactionExtractor.findTransactionMethods(ValidService.class); assertThat(transactions).hasSize(1); Method transactionMethod = ValidService.class.getMethod("transactionMethod", byte[].class, ExecutionContext.class); assertThat(singletonList(transactionMethod)) .containsExactlyElementsOf(transactions.values()); }
@Test void findMethodsValidServiceInterfaceImplementation() throws Exception { Map<Integer, Method> transactions = TransactionExtractor.findTransactionMethods( ValidServiceInterfaceImplementation.class); assertThat(transactions).hasSize(2); Method transactionMethod = ValidServiceInterfaceImplementation.class.getMethod( "transactionMethod", byte[].class, ExecutionContext.class); Method transactionMethod2 = ValidServiceInterfaceImplementation.class.getMethod( "transactionMethod2", byte[].class, ExecutionContext.class); List<Method> actualMethods = Arrays.asList(transactionMethod, transactionMethod2); assertThat(actualMethods).containsExactlyInAnyOrderElementsOf(transactions.values()); }
@Test void findTransactionMethodsValidServiceProtobufArguments() throws Exception { Map<Integer, Method> transactions = TransactionExtractor.findTransactionMethods(ValidServiceProtobufArgument.class); assertThat(transactions).hasSize(1); Method transactionMethod = ValidServiceProtobufArgument.class.getMethod("transactionMethod", TestProtoMessages.Point.class, ExecutionContext.class); assertThat(transactions.values()) .containsExactlyElementsOf(singletonList(transactionMethod)); } |
TransactionExtractor { static Map<Integer, TransactionMethod> extractTransactionMethods(Class<?> serviceClass) { Map<Integer, Method> transactionMethods = findTransactionMethods(serviceClass); Lookup lookup = MethodHandles.publicLookup() .in(serviceClass); return transactionMethods.entrySet().stream() .peek(tx -> validateTransactionMethod(tx.getValue(), serviceClass)) .collect(toMap(Map.Entry::getKey, (e) -> toTransactionMethod(e.getValue(), lookup))); } private TransactionExtractor(); } | @Test void duplicateTransactionIdsServiceMethodExtraction() { Exception e = assertThrows(IllegalArgumentException.class, () -> TransactionExtractor .extractTransactionMethods(DuplicateTransactionIdsService.class)); assertThat(e.getMessage()) .contains(String.format("Service %s has more than one transaction with the same id (%s)", DuplicateTransactionIdsService.class.getName(), DuplicateTransactionIdsService.TRANSACTION_ID), "transactionMethod", "anotherTransactionMethod"); }
@Test void missingTransactionMethodArgumentsServiceMethodExtraction() { Exception e = assertThrows(IllegalArgumentException.class, () -> TransactionExtractor .extractTransactionMethods(MissingTransactionMethodArgumentsService.class)); String methodName = "transactionMethod"; String errorMessage = String.format("Method %s in a service class %s annotated with" + " @Transaction should have precisely two parameters: transaction arguments of" + " 'byte[]' type or a protobuf type and transaction context of" + " 'com.exonum.binding.core.transaction.TransactionContext' type.", methodName, MissingTransactionMethodArgumentsService.class.getName()); assertThat(e.getMessage()).contains(errorMessage); }
@Test void invalidTransactionMethodArgumentServiceMethodExtraction() { Exception e = assertThrows(IllegalArgumentException.class, () -> TransactionExtractor .extractTransactionMethods(InvalidTransactionMethodArgumentsService.class)); String methodName = "transactionMethod"; String errorMessage = String.format("Method %s in a service class %s annotated with" + " @Transaction should have precisely two parameters: transaction arguments of" + " 'byte[]' type or a protobuf type and transaction context of" + " 'com.exonum.binding.core.transaction.TransactionContext' type." + " But second parameter type was: " + String.class.getName(), methodName, InvalidTransactionMethodArgumentsService.class.getName()); assertThat(e.getMessage()).contains(errorMessage); }
@Test void duplicateTransactionMethodArgumentServiceMethodExtraction() { Exception e = assertThrows(IllegalArgumentException.class, () -> TransactionExtractor .extractTransactionMethods(DuplicateTransactionMethodArgumentsService.class)); String methodName = "transactionMethod"; String errorMessage = String.format("Method %s in a service class %s annotated with" + " @Transaction should have precisely two parameters: transaction arguments of" + " 'byte[]' type or a protobuf type and transaction context of" + " 'com.exonum.binding.core.transaction.TransactionContext' type." + " But second parameter type was: " + byte[].class.getName(), methodName, DuplicateTransactionMethodArgumentsService.class.getName()); assertThat(e.getMessage()).contains(errorMessage); } |
TransactionInvoker { void invokeTransaction(int transactionId, byte[] arguments, ExecutionContext context) { checkArgument(transactionMethods.containsKey(transactionId), "No method with transaction id (%s)", transactionId); TransactionMethod transactionMethod = transactionMethods.get(transactionId); transactionMethod.invoke(service, arguments, context); } @Inject TransactionInvoker(Service service); } | @Test void invokeValidServiceTransaction() { ValidService service = spy(new ValidService()); TransactionInvoker invoker = new TransactionInvoker(service); invoker.invokeTransaction(TRANSACTION_ID, ARGUMENTS, context); invoker.invokeTransaction(TRANSACTION_ID_2, ARGUMENTS, context); verify(service).transactionMethod(ARGUMENTS, context); verify(service).transactionMethod2(ARGUMENTS, context); }
@Test void invokeInvalidTransactionId() { TransactionInvoker invoker = new TransactionInvoker(new ValidService()); int invalidTransactionId = Integer.MAX_VALUE; IllegalArgumentException e = assertThrows(IllegalArgumentException.class, () -> invoker.invokeTransaction(invalidTransactionId, ARGUMENTS, context)); assertThat(e.getMessage()) .contains(String.format("No method with transaction id (%s)", invalidTransactionId)); }
@Test void invokeThrowingExecutionException() { ExecutionException e = new ExecutionException((byte) 0); TransactionInvoker invoker = new TransactionInvoker(new ThrowingAnyException(e)); ExecutionException actual = assertThrows(ExecutionException.class, () -> invoker.invokeTransaction(TRANSACTION_ID, ARGUMENTS, context)); assertThat(actual).isSameAs(e); }
@Test void invokeThrowingRuntimeException() { RuntimeException e = new IllegalArgumentException("Unexpected runtime exception"); TransactionInvoker invoker = new TransactionInvoker(new ThrowingAnyException(e)); Exception actual = assertThrows(UnexpectedExecutionException.class, () -> invoker.invokeTransaction(TRANSACTION_ID, ARGUMENTS, context)); assertThat(actual).hasCause(e); }
@Test void invokeThrowingException() { IOException e = new IOException("Unexpected checked exception"); TransactionInvoker invoker = new TransactionInvoker(new ThrowingAnyException(e)); Exception actual = assertThrows(UnexpectedExecutionException.class, () -> invoker.invokeTransaction(TRANSACTION_ID, ARGUMENTS, context)); assertThat(actual).hasCause(e); }
@Test void invokeProtobufArgumentsService() { ProtobufArgumentsService service = spy(new ProtobufArgumentsService()); TransactionInvoker invoker = new TransactionInvoker(service); TestProtoMessages.Point point = TestProtoMessages.Point.newBuilder() .setX(1) .setY(1) .build(); invoker.invokeTransaction(TRANSACTION_ID, point.toByteArray(), context); verify(service).transactionMethod(point, context); } |
Fork extends AbstractAccess { public static Fork newInstance(long nativeHandle, Cleaner cleaner) { return newInstance(nativeHandle, true, cleaner); } private Fork(NativeHandle nativeHandle, ProxyDestructor destructor, Cleaner parentCleaner); static Fork newInstance(long nativeHandle, Cleaner cleaner); static Fork newInstance(long nativeHandle, boolean owningHandle, Cleaner cleaner); @Override Cleaner getCleaner(); void createCheckpoint(); void rollback(); } | @Test void canModify() { Fork fork = Fork.newInstance(0x0A, false, new Cleaner()); assertTrue(fork.canModify()); } |
OpenIndexRegistry { Optional<StorageIndex> findIndex(Long id) { return Optional.ofNullable(indexes.get(id)); } } | @Test void findUnknownIndex() { long unknownId = 1024L; Optional<StorageIndex> index = registry.findIndex(unknownId); assertThat(index).isEmpty(); } |
Snapshot extends AbstractAccess { public static Snapshot newInstance(long nativeHandle, Cleaner cleaner) { return newInstance(nativeHandle, true, cleaner); } private Snapshot(NativeHandle nativeHandle, Cleaner cleaner); static Snapshot newInstance(long nativeHandle, Cleaner cleaner); static Snapshot newInstance(long nativeHandle, boolean owningHandle, Cleaner cleaner); @Override Cleaner getCleaner(); } | @Test void cannotModify() { Snapshot s = Snapshot.newInstance(0x0A, false, new Cleaner()); assertFalse(s.canModify()); } |
ConfigurableRustIter extends AbstractNativeProxy implements RustIter<E> { @Override public Optional<E> next() { checkNotModified(); return Optional.ofNullable(nextFunction.apply(getNativeHandle())); } ConfigurableRustIter(NativeHandle nativeHandle,
LongFunction<E> nextFunction,
ModificationCounter modificationCounter); @Override Optional<E> next(); } | @Test void nextFailsIfModifiedBeforeFirstNext() { createFromIterable(emptyList()); notifyModified(); assertThrows(ConcurrentModificationException.class, () -> iter.next()); }
@Test void nextFailsIfModifiedAfterFirstNext() { createFromIterable(asList(1, 2)); iter.next(); notifyModified(); assertThrows(ConcurrentModificationException.class, () -> iter.next()); }
@Test void nextFailsIfHandleClosed() { NativeHandle nh = new NativeHandle(DEFAULT_NATIVE_HANDLE); createFromIterable(nh, asList(1, 2)); nh.close(); assertThrows(IllegalStateException.class, () -> iter.next()); }
@Test void accessModificationResultsInTerminalState() { createFromIterable(asList(1, 2)); notifyModified(); assertThrows(ConcurrentModificationException.class, () -> iter.next()); assertThrows(ConcurrentModificationException.class, () -> iter.next()); } |
QaServiceImpl extends AbstractService implements QaService { @Override public void beforeTransactions(ExecutionContext context) { incrementCounter(BEFORE_TXS_COUNTER_NAME, context); } @Inject QaServiceImpl(ServiceInstanceSpec instanceSpec); @Override void initialize(ExecutionContext context, Configuration configuration); @Override void resume(ExecutionContext context, byte[] arguments); @Override void createPublicApiHandlers(Node node, Router router); @Override void beforeTransactions(ExecutionContext context); @Override void afterTransactions(ExecutionContext context); @Override void afterCommit(BlockCommittedEvent event); @Override HashCode submitIncrementCounter(long requestSeed, String counterName); @Override HashCode submitUnknownTx(); @Override @SuppressWarnings("ConstantConditions") // Node is not null. Optional<Counter> getValue(String counterName); @Override Config getConsensusConfiguration(); @Override @SuppressWarnings("ConstantConditions") // Node is not null. Optional<ZonedDateTime> getTime(); @Override @SuppressWarnings("ConstantConditions") // Node is not null. Map<PublicKey, ZonedDateTime> getValidatorsTimes(); @Override void verifyConfiguration(ExecutionContext context, Configuration configuration); @Override void applyConfiguration(ExecutionContext context, Configuration configuration); @Override @Transaction(CREATE_COUNTER_TX_ID) void createCounter(TxMessageProtos.CreateCounterTxBody arguments,
ExecutionContext context); @Override @Transaction(INCREMENT_COUNTER_TX_ID) void incrementCounter(TxMessageProtos.IncrementCounterTxBody arguments,
ExecutionContext context); @Override @Transaction(VALID_THROWING_TX_ID) void throwing(TxMessageProtos.ThrowingTxBody arguments, ExecutionContext context); @Override @Transaction(VALID_ERROR_TX_ID) void error(TxMessageProtos.ErrorTxBody arguments, ExecutionContext context); } | @Test void beforeTransactions(TestKit testKit) { checkCounter(testKit, BEFORE_TXS_COUNTER_NAME, 0L); for (int i = 1; i <= 2; i++) { testKit.createBlock(); checkCounter(testKit, BEFORE_TXS_COUNTER_NAME, i); } } |
AbstractIndexProxy extends AbstractNativeProxy implements StorageIndex { void notifyModified() { checkCanModify(); modCounter.notifyModified(); } AbstractIndexProxy(NativeHandle nativeHandle, IndexAddress address, AbstractAccess access); @Override IndexAddress getAddress(); @Override String toString(); } | @Test void notifyModifiedThrowsIfSnapshotPassed() { Snapshot dbView = createSnapshot(); proxy = new IndexProxyImpl(dbView); UnsupportedOperationException thrown = assertThrows(UnsupportedOperationException.class, () -> proxy.notifyModified()); Pattern pattern = Pattern.compile("Cannot modify the access: .*[Ss]napshot.*" + "\\nUse a Fork to modify any collection\\.", Pattern.MULTILINE); assertThat(thrown, hasMessage(matchesPattern(pattern))); } |
RustIterAdapter implements Iterator<E> { @Override public E next() { E element = nextItem.orElseThrow( () -> new NoSuchElementException("Reached the end of the underlying collection. " + "Use #hasNext to check if you have reached the end of the collection.")); nextItem = rustIter.next(); return element; } RustIterAdapter(RustIter<E> rustIter); @Override boolean hasNext(); @Override E next(); } | @Test void nextThrowsIfNoNextItem0() { adapter = new RustIterAdapter<>( new RustIterTestFake(emptyList())); assertThrows(NoSuchElementException.class, () -> adapter.next()); }
@Test void nextThrowsIfNoNextItem1() { adapter = new RustIterAdapter<>( new RustIterTestFake(singletonList(1))); adapter.next(); assertThrows(NoSuchElementException.class, () -> adapter.next()); } |
StoragePreconditions { @CanIgnoreReturnValue static String checkIndexName(String name) { checkArgument(!name.isEmpty(), "name is empty"); return name; } private StoragePreconditions(); } | @Test void checkIndexNameAcceptsNonEmpty() { String name = "table1"; assertThat(name, sameInstance(StoragePreconditions.checkIndexName(name))); }
@Test void checkIndexNameDoesNotAcceptNull() { assertThrows(NullPointerException.class, () -> StoragePreconditions.checkIndexName(null)); }
@Test void checkIndexNameDoesNotAcceptEmpty() { assertThrows(IllegalArgumentException.class, () -> { String name = ""; StoragePreconditions.checkIndexName(name); }); } |
StoragePreconditions { @CanIgnoreReturnValue static byte[] checkIdInGroup(byte[] indexId) { checkArgument(indexId.length > 0, "index identifier must not be empty"); return indexId; } private StoragePreconditions(); } | @Test void checkIdInGroup() { byte[] validId = bytes("id1"); assertThat(StoragePreconditions.checkIdInGroup(validId), sameInstance(validId)); }
@Test void checkIdInGroupNull() { assertThrows(NullPointerException.class, () -> StoragePreconditions.checkIdInGroup(null)); }
@Test void checkIdInGroupEmpty() { byte[] emptyId = new byte[0]; assertThrows(IllegalArgumentException.class, () -> StoragePreconditions.checkIdInGroup(emptyId)); } |
QaServiceImpl extends AbstractService implements QaService { @Override public void afterTransactions(ExecutionContext context) { incrementCounter(AFTER_TXS_COUNTER_NAME, context); } @Inject QaServiceImpl(ServiceInstanceSpec instanceSpec); @Override void initialize(ExecutionContext context, Configuration configuration); @Override void resume(ExecutionContext context, byte[] arguments); @Override void createPublicApiHandlers(Node node, Router router); @Override void beforeTransactions(ExecutionContext context); @Override void afterTransactions(ExecutionContext context); @Override void afterCommit(BlockCommittedEvent event); @Override HashCode submitIncrementCounter(long requestSeed, String counterName); @Override HashCode submitUnknownTx(); @Override @SuppressWarnings("ConstantConditions") // Node is not null. Optional<Counter> getValue(String counterName); @Override Config getConsensusConfiguration(); @Override @SuppressWarnings("ConstantConditions") // Node is not null. Optional<ZonedDateTime> getTime(); @Override @SuppressWarnings("ConstantConditions") // Node is not null. Map<PublicKey, ZonedDateTime> getValidatorsTimes(); @Override void verifyConfiguration(ExecutionContext context, Configuration configuration); @Override void applyConfiguration(ExecutionContext context, Configuration configuration); @Override @Transaction(CREATE_COUNTER_TX_ID) void createCounter(TxMessageProtos.CreateCounterTxBody arguments,
ExecutionContext context); @Override @Transaction(INCREMENT_COUNTER_TX_ID) void incrementCounter(TxMessageProtos.IncrementCounterTxBody arguments,
ExecutionContext context); @Override @Transaction(VALID_THROWING_TX_ID) void throwing(TxMessageProtos.ThrowingTxBody arguments, ExecutionContext context); @Override @Transaction(VALID_ERROR_TX_ID) void error(TxMessageProtos.ErrorTxBody arguments, ExecutionContext context); } | @Test void afterTransactions(TestKit testKit) { checkCounter(testKit, AFTER_TXS_COUNTER_NAME, 1L); for (int i = 1; i <= 2; i++) { testKit.createBlock(); checkCounter(testKit, AFTER_TXS_COUNTER_NAME, 1L + i); } } |
StoragePreconditions { @CanIgnoreReturnValue static byte[] checkStorageKey(byte[] key) { return checkNotNull(key, "Storage key is null"); } private StoragePreconditions(); } | @Test void checkStorageKeyAcceptsEmpty() { byte[] key = new byte[]{}; assertThat(key, sameInstance(StoragePreconditions.checkStorageKey(key))); }
@Test void checkStorageKeyAcceptsNonEmpty() { byte[] key = bytes('k'); assertThat(key, sameInstance(StoragePreconditions.checkStorageKey(key))); }
@Test void checkStorageKeyDoesNotAcceptNull() { assertThrows(NullPointerException.class, () -> StoragePreconditions.checkStorageKey(null)); }
@Test void checkStorageValueDoesNotAcceptNull() { assertThrows(NullPointerException.class, () -> StoragePreconditions.checkStorageKey(null)); } |
StoragePreconditions { @CanIgnoreReturnValue static byte[] checkProofKey(byte[] key) { checkNotNull(key, "Proof map key is null"); checkArgument(key.length == PROOF_MAP_KEY_SIZE, "Proof map key has invalid size (%s), must be 32 bytes", key.length); return key; } private StoragePreconditions(); } | @Test void checkProofKeyAccepts32ByteZeroKey() { byte[] key = new byte[32]; assertThat(key, sameInstance(StoragePreconditions.checkProofKey(key))); }
@Test void checkProofKeyAccepts32ByteNonZeroKey() { byte[] key = bytes("0123456789abcdef0123456789abcdef"); assertThat(key, sameInstance(StoragePreconditions.checkProofKey(key))); }
@Test void checkProofKeyDoesNotAcceptNull() { NullPointerException thrown = assertThrows(NullPointerException.class, () -> StoragePreconditions.checkProofKey(null)); assertThat(thrown.getLocalizedMessage(), containsString("Proof map key is null")); }
@Test void checkProofKeyDoesNotAcceptSmallerKeys() { byte[] key = new byte[1]; IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> StoragePreconditions.checkProofKey(key)); assertThat(thrown.getLocalizedMessage(), containsString("Proof map key has invalid size (1)")); }
@Test void checkProofKeyDoesNotAcceptBiggerKeys() { byte[] key = new byte[64]; IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> StoragePreconditions.checkProofKey(key)); assertThat(thrown.getLocalizedMessage(), containsString("Proof map key has invalid size (64)")); } |
StoragePreconditions { @CanIgnoreReturnValue static byte[] checkStorageValue(byte[] value) { return checkNotNull(value, "Storage value is null"); } private StoragePreconditions(); } | @Test void checkStorageValueAcceptsEmpty() { byte[] value = new byte[]{}; assertThat(value, sameInstance(StoragePreconditions.checkStorageValue(value))); }
@Test void checkStorageValueAcceptsNonEmpty() { byte[] value = bytes('v'); assertThat(value, sameInstance(StoragePreconditions.checkStorageValue(value))); } |
QaServiceImpl extends AbstractService implements QaService { @Override public void afterCommit(BlockCommittedEvent event) { long seed = event.getHeight(); submitIncrementCounter(seed, AFTER_COMMIT_COUNTER_NAME); } @Inject QaServiceImpl(ServiceInstanceSpec instanceSpec); @Override void initialize(ExecutionContext context, Configuration configuration); @Override void resume(ExecutionContext context, byte[] arguments); @Override void createPublicApiHandlers(Node node, Router router); @Override void beforeTransactions(ExecutionContext context); @Override void afterTransactions(ExecutionContext context); @Override void afterCommit(BlockCommittedEvent event); @Override HashCode submitIncrementCounter(long requestSeed, String counterName); @Override HashCode submitUnknownTx(); @Override @SuppressWarnings("ConstantConditions") // Node is not null. Optional<Counter> getValue(String counterName); @Override Config getConsensusConfiguration(); @Override @SuppressWarnings("ConstantConditions") // Node is not null. Optional<ZonedDateTime> getTime(); @Override @SuppressWarnings("ConstantConditions") // Node is not null. Map<PublicKey, ZonedDateTime> getValidatorsTimes(); @Override void verifyConfiguration(ExecutionContext context, Configuration configuration); @Override void applyConfiguration(ExecutionContext context, Configuration configuration); @Override @Transaction(CREATE_COUNTER_TX_ID) void createCounter(TxMessageProtos.CreateCounterTxBody arguments,
ExecutionContext context); @Override @Transaction(INCREMENT_COUNTER_TX_ID) void incrementCounter(TxMessageProtos.IncrementCounterTxBody arguments,
ExecutionContext context); @Override @Transaction(VALID_THROWING_TX_ID) void throwing(TxMessageProtos.ThrowingTxBody arguments, ExecutionContext context); @Override @Transaction(VALID_ERROR_TX_ID) void error(TxMessageProtos.ErrorTxBody arguments, ExecutionContext context); } | @Test void afterCommit(TestKit testKit) { testKit.createBlock(); checkAfterCommitCounter(testKit, 1L); testKit.createBlock(); checkAfterCommitCounter(testKit, 2L); } |
ExplorerApiHelper { static TransactionResponse parseGetTxResponse(String json) { GetTxResponse response = JSON.fromJson(json, GetTxResponse.class); ExecutionStatus executionResult = getExecutionStatus(response.getStatus()); return new TransactionResponse( response.getType(), response.getMessage(), executionResult, response.getLocation() ); } private ExplorerApiHelper(); } | @Test void parseGetTxResponseInPool() { String json = "{\n" + " 'type': 'in-pool',\n" + " 'message': '" + toHex(TRANSACTION_MESSAGE) + "'\n" + "}"; TransactionResponse transactionResponse = ExplorerApiHelper.parseGetTxResponse(json); assertThat(transactionResponse.getStatus(), is(TransactionStatus.IN_POOL)); assertThat(transactionResponse.getMessage(), is(TRANSACTION_MESSAGE)); assertThrows(IllegalStateException.class, transactionResponse::getExecutionResult); assertThrows(IllegalStateException.class, transactionResponse::getLocation); } |
StoragePreconditions { static <E> void checkNoNulls(Collection<E> collection) { checkNotNull(collection, "Collection is null"); if (collection.contains(null)) { throw new NullPointerException("Collection contains nulls"); } } private StoragePreconditions(); } | @Test void checkNoNulls() { assertThrows(NullPointerException.class, () -> { Collection<String> c = Arrays.asList("hello", null); StoragePreconditions.checkNoNulls(c); }); } |
StoragePreconditions { @CanIgnoreReturnValue static long checkElementIndex(long index, long size) { if (index < 0L || size <= index) { throw new IndexOutOfBoundsException("Index must be in range [0, " + size + ")," + " but: " + index); } return index; } private StoragePreconditions(); } | @Test void checkElementIndexNegative() { IndexOutOfBoundsException thrown = assertThrows(IndexOutOfBoundsException.class, () -> StoragePreconditions.checkElementIndex(-1, 2)); assertThat(thrown.getLocalizedMessage(), containsString("Index must be in range [0, 2), but: -1")); }
@Test void checkElementIndexEqualToSize() { IndexOutOfBoundsException thrown = assertThrows(IndexOutOfBoundsException.class, () -> StoragePreconditions.checkElementIndex(2, 2)); assertThat(thrown.getLocalizedMessage(), containsString("Index must be in range [0, 2), but: 2")); }
@Test void checkElementIndexGreaterThanSize() { IndexOutOfBoundsException thrown = assertThrows(IndexOutOfBoundsException.class, () -> StoragePreconditions.checkElementIndex(3, 2)); assertThat(thrown.getLocalizedMessage(), containsString("Index must be in range [0, 2), but: 3")); }
@Test void checkElementIndexMaxLong() { IndexOutOfBoundsException thrown = assertThrows(IndexOutOfBoundsException.class, () -> StoragePreconditions.checkElementIndex(Long.MAX_VALUE, 2)); assertThat(thrown.getLocalizedMessage(), containsString("Index must be in range [0, 2), but:")); }
@Test void checkElementIndex0MinValid() { long index = 0; long size = 3; assertThat(StoragePreconditions.checkElementIndex(index, size), equalTo(index)); }
@Test void checkElementIndex1() { long index = 1; long size = 3; assertThat(StoragePreconditions.checkElementIndex(index, size), equalTo(index)); }
@Test void checkElementIndex2MaxValid() { long index = 2; long size = 3; assertThat(StoragePreconditions.checkElementIndex(index, size), equalTo(index)); } |
StoragePreconditions { @CanIgnoreReturnValue static long checkPositionIndex(long index, long size) { if (index < 0 || index > size) { throw new IndexOutOfBoundsException(badPositionIndex(index, size)); } return index; } private StoragePreconditions(); } | @Test void checkPositionIndexSize0_Valid() { long index = 0; long size = 0; assertThat(StoragePreconditions.checkPositionIndex(index, size), equalTo(index)); }
@Test void checkPositionIndexSize0_NotValid() { long index = 1; long size = 0; IndexOutOfBoundsException thrown = assertThrows(IndexOutOfBoundsException.class, () -> StoragePreconditions.checkPositionIndex(index, size)); assertThat(thrown.getLocalizedMessage(), containsString("index (1) is greater than size (0)")); }
@Test void checkPositionIndexSize0_NotValidNegative() { long index = -1; long size = 0; IndexOutOfBoundsException thrown = assertThrows(IndexOutOfBoundsException.class, () -> StoragePreconditions.checkPositionIndex(index, size)); assertThat(thrown.getLocalizedMessage(), containsString("index (-1) is negative")); }
@Test void checkPositionIndexSize3_AllValid() { long size = 3; long[] validIndices = {0, 1, 2, 3}; for (long index : validIndices) { assertThat(StoragePreconditions.checkPositionIndex(index, size), equalTo(index)); } }
@Test void checkPositionIndexSize3_NotValid() { long index = 4; long size = 3; IndexOutOfBoundsException thrown = assertThrows(IndexOutOfBoundsException.class, () -> StoragePreconditions.checkPositionIndex(index, size)); assertThat(thrown.getLocalizedMessage(), containsString("index (4) is greater than size (3)")); }
@Test void checkPositionIndex_NegativeSize() { long index = 0; long size = -1; IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> StoragePreconditions.checkPositionIndex(index, size)); assertThat(thrown.getLocalizedMessage(), containsString("size (-1) is negative")); } |
CryptoUtils { static boolean hasLength(byte[] data, int size) { return data.length == size; } private CryptoUtils(); } | @Test void hasLength() { byte[] bytes = new byte[10]; assertTrue(CryptoUtils.hasLength(bytes, 10)); } |
StoragePreconditions { static void checkRange(long from, long to) { if (from < 0 || from >= to) { throw new IndexOutOfBoundsException("Proof range first element index " + from + " must be in range [0, " + to + ")"); } } private StoragePreconditions(); } | @Test void checkRangeFromNegative() { IndexOutOfBoundsException thrown = assertThrows(IndexOutOfBoundsException.class, () -> checkRange(-1, 2)); assertThat(thrown.getLocalizedMessage(), containsString("Proof range first element index -1 must be in range [0, 2)")); }
@Test void checkRangeFromEqualToTo() { IndexOutOfBoundsException thrown = assertThrows(IndexOutOfBoundsException.class, () -> checkRange(2, 2)); assertThat(thrown.getLocalizedMessage(), containsString("Proof range first element index 2 must be in range [0, 2)")); }
@Test void checkRangeFromGreaterThanTo() { IndexOutOfBoundsException thrown = assertThrows(IndexOutOfBoundsException.class, () -> checkRange(3, 2)); assertThat(thrown.getLocalizedMessage(), containsString("Proof range first element index 3 must be in range [0, 2)")); }
@Test void checkRangeFromMaxLong() { IndexOutOfBoundsException thrown = assertThrows(IndexOutOfBoundsException.class, () -> checkRange(Long.MAX_VALUE, 2)); assertThat(thrown.getLocalizedMessage(), containsString("Proof range first element index " + Long.MAX_VALUE + " must be in range [0, 2)")); }
@Test void checkRangeFrom0MinValid() { long from = 0; long to = 3; checkRange(from, to); }
@Test void checkRangeFrom1() { long from = 1; long to = 3; checkRange(from, to); }
@Test void checkRangeFrom2MaxValid() { long from = 2; long to = 3; checkRange(from, to); } |
CryptoUtils { static byte[] hexToByteArray(String hex) { return HEX_ENCODING.decode(hex); } private CryptoUtils(); } | @Test void hexToByteArray() { byte[] bytes = CryptoUtils.hexToByteArray("abcd"); assertEquals(2, bytes.length); assertEquals(-85, bytes[0]); assertEquals(-51, bytes[1]); } |
ListSpliterator implements Spliterator<ElementT> { @Override public Spliterator<ElementT> trySplit() { bindOrCheckModifications(); if (estimateSize() < MIN_SPLITTABLE_SIZE) { return null; } long mid = nextIndex + (fence - nextIndex) / 2; Spliterator<ElementT> prefix = new ListSpliterator<>(list, counter, hasCharacteristics(IMMUTABLE), nextIndex, mid, initialCounterValue); this.nextIndex = mid; return prefix; } ListSpliterator(ListIndex<ElementT> list, ModificationCounter counter, boolean immutable); private ListSpliterator(ListIndex<ElementT> list, ModificationCounter counter, boolean immutable,
long nextIndex, long fence, Integer initialCounterValue); @Override boolean tryAdvance(Consumer<? super ElementT> action); @Override Spliterator<ElementT> trySplit(); @Override long estimateSize(); @Override int characteristics(); } | @Test void trySplit_Empty() { int[] source = new int[0]; Spliterator<Integer> spliterator = createSpliteratorOf(source); assertNull(spliterator.trySplit()); }
@Test @DisplayName("trySplit if there are less than minimal splittable size (1 element)") void trySplit_OneElement() { Spliterator<Integer> spliterator = createSpliteratorOf(new int[1]); assertNull(spliterator.trySplit()); }
@Test void spliteratorRemainsBoundToTheSourceAfterSplit() { ListIndex<Integer> list = createListMock(); when(list.size()).thenReturn(10L); ModificationCounter counter = new IncrementalModificationCounter(); Spliterator<Integer> spliterator = new ListSpliterator<>(list, counter, true); Spliterator<Integer> other = spliterator.trySplit(); counter.notifyModified(); assertHasDetectedModification(spliterator); assertHasDetectedModification(other); } |
ListSpliterator implements Spliterator<ElementT> { @Override public long estimateSize() { bindOrCheckModifications(); return fence - nextIndex; } ListSpliterator(ListIndex<ElementT> list, ModificationCounter counter, boolean immutable); private ListSpliterator(ListIndex<ElementT> list, ModificationCounter counter, boolean immutable,
long nextIndex, long fence, Integer initialCounterValue); @Override boolean tryAdvance(Consumer<? super ElementT> action); @Override Spliterator<ElementT> trySplit(); @Override long estimateSize(); @Override int characteristics(); } | @Test @DisplayName("spliterator uses the list size at bind time, allowing for structural modifications") void spliteratorIsLateBindingUsesProperSize() { ListIndex<Integer> list = createListMock(); long initialSize = 10; lenient().when(list.size()).thenReturn(initialSize); ModificationCounter counter = new IncrementalModificationCounter(); Spliterator<Integer> spliterator = new ListSpliterator<>(list, counter, true); long size = initialSize + 1; when(list.size()).thenReturn(size); counter.notifyModified(); assertThat(spliterator.estimateSize()).isEqualTo(size); }
@Test void estimateSizeIsZeroAfterSpliteratorIsConsumed() { ListIndex<Integer> list = createListMock(); long listSize = 5; when(list.size()).thenReturn(listSize); ModificationCounter counter = mock(ModificationCounter.class); Spliterator<Integer> spliterator = new ListSpliterator<>(list, counter, true); spliterator.forEachRemaining(NULL_CONSUMER); assertThat(spliterator.estimateSize()).isEqualTo(0); } |
Block { public final boolean isEmpty() { return getNumTransactions() == 0; } abstract HashCode getBlockHash(); abstract int getProposerId(); abstract long getHeight(); final boolean isEmpty(); abstract int getNumTransactions(); abstract HashCode getPreviousBlockHash(); abstract HashCode getTxRootHash(); abstract HashCode getStateHash(); abstract HashCode getErrorHash(); abstract ImmutableMap<String, ByteString> getAdditionalHeaders(); @SuppressWarnings("squid:S1206") @Override int hashCode(); static TypeAdapter<Block> typeAdapter(Gson gson); static Block fromMessage(com.exonum.messages.core.Blockchain.Block blockMessage); static Block parseFrom(byte[] serializedBlock); static Builder builder(); } | @Test void isEmpty() { Block emptyBlock = Blocks.aBlock() .numTransactions(0) .build(); assertTrue(emptyBlock.isEmpty()); } |
ApiController { private void getWallet(RoutingContext rc) { PublicKey walletId = getRequiredParameter(rc.request(), WALLET_ID_PARAM, PublicKey::fromHexString); Optional<Wallet> wallet = service.getWallet(walletId); if (wallet.isPresent()) { rc.response() .putHeader(CONTENT_TYPE, "application/json") .end(json().toJson(wallet.get())); } else { rc.response() .setStatusCode(HTTP_NOT_FOUND) .end(); } } ApiController(CryptocurrencyService service); } | @Test void getWallet(VertxTestContext context) { long balance = 200L; Wallet wallet = new Wallet(balance); when(service.getWallet(eq(FROM_KEY))) .thenReturn(Optional.of(wallet)); String getWalletUri = getWalletUri(FROM_KEY); get(getWalletUri) .send(context.succeeding(response -> context.verify(() -> { assertThat(response.statusCode()) .isEqualTo(HTTP_OK); String body = response.bodyAsString(); Wallet actualWallet = json() .fromJson(body, Wallet.class); assertThat(actualWallet.getBalance()).isEqualTo(wallet.getBalance()); context.completeNow(); }))); }
@Test void getNonexistentWallet(VertxTestContext context) { when(service.getWallet(FROM_KEY)) .thenReturn(Optional.empty()); String getWalletUri = getWalletUri(FROM_KEY); get(getWalletUri) .send(context.succeeding(response -> context.verify(() -> { assertThat(response.statusCode()).isEqualTo(HTTP_NOT_FOUND); context.completeNow(); }))); } |
CryptoUtils { static String byteArrayToHex(byte[] bytes) { return HEX_ENCODING.encode(bytes); } private CryptoUtils(); } | @Test void byteArrayToHex() { String hex = CryptoUtils.byteArrayToHex(new byte[]{-85, -51}); assertEquals("abcd", hex); } |
ApiController { private void getWalletHistory(RoutingContext rc) { PublicKey walletId = getRequiredParameter(rc.request(), WALLET_ID_PARAM, PublicKey::fromHexString); List<HistoryEntity> walletHistory = service.getWalletHistory(walletId); rc.response() .putHeader(CONTENT_TYPE, "application/json") .end(json().toJson(walletHistory)); } ApiController(CryptocurrencyService service); } | @Test void getWalletHistory(VertxTestContext context) { List<HistoryEntity> history = singletonList( HistoryEntity.newBuilder() .setSeed(1L) .setWalletFrom(FROM_KEY) .setWalletTo(TO_KEY) .setAmount(10L) .setTxMessageHash(HashCode.fromString("a0a0a0")) .build() ); when(service.getWalletHistory(FROM_KEY)).thenReturn(history); String uri = getWalletUri(FROM_KEY) + "/history"; get(uri) .send(context.succeeding(response -> context.verify(() -> { assertThat(response.statusCode()).isEqualTo(HTTP_OK); List<HistoryEntity> actualHistory = parseWalletHistory(response); assertThat(actualHistory).isEqualTo(history); context.completeNow(); }))); }
@Test void getWalletHistoryNonexistentWallet(VertxTestContext context) { when(service.getWalletHistory(FROM_KEY)).thenReturn(emptyList()); String uri = getWalletUri(FROM_KEY) + "/history"; get(uri) .send(context.succeeding(response -> context.verify(() -> { assertThat(response.statusCode()).isEqualTo(HTTP_OK); assertThat(parseWalletHistory(response)).isEmpty(); context.completeNow(); }))); } |
SignedMessage { public static SignedMessage parseFrom(byte[] messageBytes) throws InvalidProtocolBufferException { HashCode hash = sha256().hashBytes(messageBytes); Messages.SignedMessage message = Messages.SignedMessage.parseFrom(messageBytes); return fromProto(message, hash); } private SignedMessage(CoreMessage payload, PublicKey authorPk,
ByteString signature, HashCode hash); static SignedMessage parseFrom(byte[] messageBytes); static SignedMessage fromProto(Messages.SignedMessage message); Messages.CoreMessage getPayload(); PublicKey getAuthorPk(); byte[] getSignature(); HashCode hash(); } | @Test void parseFromWrongMessage() { byte[] message = bytes("Not a signed message"); assertThrows(InvalidProtocolBufferException.class, () -> SignedMessage.parseFrom(message)); }
@Test void parseFromPayloadNotExonumMessage() { ByteString invalidPayload = ByteString.copyFrom( bytes("Invalid payload: not an ExonumMessage")); Types.PublicKey authorPk = aPublicKey().build(); Types.Signature signature = aSignature().build(); byte[] message = Messages.SignedMessage.newBuilder() .setPayload(invalidPayload) .setAuthor(authorPk) .setSignature(signature) .build() .toByteArray(); assertThrows(InvalidProtocolBufferException.class, () -> SignedMessage.parseFrom(message)); } |
ParsedTransactionMessage implements TransactionMessage { @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof ParsedTransactionMessage)) { return false; } ParsedTransactionMessage that = (ParsedTransactionMessage) o; return signedMessage.equals(that.signedMessage); } ParsedTransactionMessage(Messages.SignedMessage signedMessage); @Override PublicKey getAuthor(); @Override int getServiceId(); @Override int getTransactionId(); @Override ByteString getPayload(); @Override HashCode hash(); @Override byte[] getSignature(); @Override byte[] toBytes(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); } | @Test void testEquals() throws InvalidProtocolBufferException { String red = "Red"; String black = "Black"; EqualsVerifier.forClass(ParsedTransactionMessage.class) .suppress(Warning.NULL_FIELDS) .withOnlyTheseFields("signedMessage") .withPrefabValues(Messages.SignedMessage.class, signedConsensusMessage(red), signedConsensusMessage(black)) .withPrefabValues(SignedMessage.class, signedMessage(red), signedMessage(black)) .withPrefabValues(AnyTx.class, anyTx(red), anyTx(black)) .verify(); } |
JsonSerializer { public static Gson json() { return INSTANCE; } private JsonSerializer(); static GsonBuilder builder(); static Gson json(); } | @Test void longSerializesAsText() { long value = 10L; String json = json().toJson(new Wrapper<>(value)); assertJsonValue(json, "10"); }
@Test void publicKeySerializesAsHexValue() { PublicKey value = PublicKey.fromBytes(bytes(0x00, 0x01, 0x02)); String json = json().toJson(new Wrapper<>(value)); assertJsonValue(json, "000102"); }
@Test void hashCodeSerializesAsValue() { HashCode value = HashCode.fromBytes(bytes(0x00, 0x01, 0x02)); String json = json().toJson(new Wrapper<>(value)); assertJsonValue(json, "000102"); }
@Test void transactionMessageSerializesAsValue() { TransactionMessage value = aMessage(); String json = json().toJson(new Wrapper<>(value)); String expectedValue = Bytes.toHexString(value.toBytes()); assertJsonValue(json, expectedValue); } |
ExplorerApiHelper { static BlockResponse parseGetBlockResponse(String json) { GetBlockResponse response = JSON.fromJson(json, GetBlockResponse.class); List<HashCode> txs = response.getTxs().stream() .map(IndexedTxHash::getTxHash) .collect(toList()); return new BlockResponse(response.getAsBlock(), txs); } private ExplorerApiHelper(); } | @Test void parseGetBlockResponse() { String prevHash = "81abde95"; String txHash = "c6c0aa07"; String stateHash = "2eab5971"; String tx1 = "336a4acb"; String tx2 = "12345678"; String commitTime = "2019-10-01T17:07:45.663021Z"; String json = "{\n" + " \"proposer_id\": 0,\n" + " \"height\": 2,\n" + " \"tx_count\": 1,\n" + " \"prev_hash\": \"" + prevHash + "\",\n" + " \"tx_hash\": \"" + txHash + "\",\n" + " \"state_hash\": \"" + stateHash + "\",\n" + " \"precommits\": [\n" + " \"bc13da11\"\n" + " ],\n" + " \"txs\": [\n" + " {\"service_id\": 0, \"tx_hash\": \"" + tx1 + "\"},\n" + " {\"service_id\": 128, \"tx_hash\": \"" + tx2 + "\"}\n" + " ],\n" + " \"time\": \"" + commitTime + "\"\n" + "}"; BlockResponse response = ExplorerApiHelper.parseGetBlockResponse(json); Block expectedBlock = Block.builder() .proposerId(0) .height(2) .numTransactions(1) .previousBlockHash(HashCode.fromString(prevHash)) .txRootHash(HashCode.fromString(txHash)) .stateHash(HashCode.fromString(stateHash)) .commitTime(ZonedDateTime.parse(commitTime)) .build(); assertThat(response.getBlock(), is(expectedBlock)); assertThat(response.getTransactionHashes(), contains(HashCode.fromString(tx1), HashCode.fromString(tx2))); } |
ProtobufReflectiveSerializer implements Serializer<MessageT> { @Override public byte[] toBytes(MessageT value) { byte[] result = new byte[value.getSerializedSize()]; CodedOutputStream output = CodedOutputStream.newInstance(result); output.useDeterministicSerialization(); try { value.writeTo(output); output.checkNoSpaceLeft(); return result; } catch (IOException e) { throw new AssertionError("Failed to serialize " + value + " to a byte array (should never happen)", e); } } ProtobufReflectiveSerializer(Class<MessageT> messageType); @Override byte[] toBytes(MessageT value); @SuppressWarnings("unchecked") @Override MessageT fromBytes(byte[] serializedValue); } | @Test void toBytes() { Point p = createPoint(-1, 1); assertThat(serializer.toBytes(p), equalTo(p.toByteArray())); }
@Test void toBytesIsDeterministic() { Point p1 = createPoint(-1, -1); Point p2 = createPoint(1, 1); Point p3 = createPoint(Integer.MIN_VALUE, Integer.MAX_VALUE); Targets t1 = pointsAsTargetsInOrder(p1, p2, p3); Targets t2 = pointsAsTargetsInOrder(p3, p2, p1); ProtobufReflectiveSerializer<Targets> serializer = new ProtobufReflectiveSerializer<>(Targets.class); assertThat("The protobuf serializer is not deterministic:", serializer.toBytes(t1), equalTo(serializer.toBytes(t2))); }
@Test void toBytesNullMessage() { assertThrows(NullPointerException.class, () -> serializer.toBytes(null)); } |
ProtobufReflectiveSerializer implements Serializer<MessageT> { @SuppressWarnings("unchecked") @Override public MessageT fromBytes(byte[] serializedValue) { checkNotNull(serializedValue); try { return (MessageT) messageParseFrom.invoke(serializedValue); } catch (InvalidProtocolBufferException e) { throw new IllegalArgumentException(e); } catch (Throwable throwable) { throw new AssertionError("Unexpected exception in MessageT#parseFrom", throwable); } } ProtobufReflectiveSerializer(Class<MessageT> messageType); @Override byte[] toBytes(MessageT value); @SuppressWarnings("unchecked") @Override MessageT fromBytes(byte[] serializedValue); } | @Test void fromBytesNull() { assertThrows(NullPointerException.class, () -> serializer.fromBytes(null)); }
@Test void fromBytesInvalidInput() { byte[] invalidBuffer = new byte[32]; assertThrows(IllegalArgumentException.class, () -> serializer.fromBytes(invalidBuffer)); } |
CheckingSerializerDecorator implements Serializer<T> { public static <T> CheckingSerializerDecorator<T> from(Serializer<T> serializer) { if (serializer instanceof CheckingSerializerDecorator) { return (CheckingSerializerDecorator<T>) serializer; } return new CheckingSerializerDecorator<>(serializer); } private CheckingSerializerDecorator(Serializer<T> delegate); static CheckingSerializerDecorator<T> from(Serializer<T> serializer); @Override byte[] toBytes(T value); @Override T fromBytes(byte[] serializedValue); } | @Test void fromSelf() { assertThat(CheckingSerializerDecorator.from(decorator), sameInstance(decorator)); } |
CheckingSerializerDecorator implements Serializer<T> { @Override public byte[] toBytes(T value) { byte[] valueBytes = delegate.toBytes(checkNotNull(value, "value is null")); checkState(valueBytes != null, "Broken serializer (%s): produces null byte array for a non-null value", delegate); return valueBytes; } private CheckingSerializerDecorator(Serializer<T> delegate); static CheckingSerializerDecorator<T> from(Serializer<T> serializer); @Override byte[] toBytes(T value); @Override T fromBytes(byte[] serializedValue); } | @Test void toBytes() { Object value = new Object(); byte[] valueBytes = new byte[0]; when(delegateMock.toBytes(value)).thenReturn(valueBytes); assertThat(decorator.toBytes(value), equalTo(valueBytes)); }
@Test void toBytes_NullValue() { assertThrows(NullPointerException.class, () -> decorator.toBytes(null)); }
@Test void toBytes_NullFromDelegate() { when(delegateMock.toBytes(any())).thenReturn(null); expectBrokenSerializerException(() -> decorator.toBytes(new Object())); }
@Test void fromBytes_NullValue() { assertThrows(NullPointerException.class, () -> decorator.toBytes(null)); } |
CheckingSerializerDecorator implements Serializer<T> { @Override public T fromBytes(byte[] serializedValue) { T value = delegate.fromBytes(checkNotNull(serializedValue, "serializedValue is null")); checkState(value != null, "Broken serializer (%s): produces a null value for a non-null array." + " You must throw an exception if a serialized value cannot be converted " + "to an instance of the given type.", delegate); return value; } private CheckingSerializerDecorator(Serializer<T> delegate); static CheckingSerializerDecorator<T> from(Serializer<T> serializer); @Override byte[] toBytes(T value); @Override T fromBytes(byte[] serializedValue); } | @Test void fromBytes() { Object value = new Object(); byte[] valueBytes = new byte[0]; when(delegateMock.fromBytes(valueBytes)).thenReturn(value); assertThat(decorator.fromBytes(valueBytes), equalTo(value)); }
@Test void fromBytes_NullFromDelegate() { when(delegateMock.fromBytes(any())).thenReturn(null); expectBrokenSerializerException(() -> decorator.fromBytes(new byte[0])); } |
ExplorerApiHelper { static BlocksResponse parseGetBlocksResponse(String json) { GetBlocksResponse response = JSON.fromJson(json, GetBlocksResponse.class); return new BlocksResponse( response.getBlocks(), response.getRange().getStart(), response.getRange().getEnd() ); } private ExplorerApiHelper(); } | @Test void parseGetBlocksResponse() { String json = "{\n" + " 'range': {\n" + " 'start': 6,\n" + " 'end': 288\n" + " },\n" + " 'blocks': [ " + BLOCK_1_JSON + "," + BLOCK_2_JSON + "," + BLOCK_3_JSON + "]\n" + "}\n"; BlocksResponse response = ExplorerApiHelper.parseGetBlocksResponse(json); assertThat(response.getBlocks(), contains(BLOCK_1, BLOCK_2, BLOCK_3)); assertThat(response.getBlocksRangeStart(), is(6L)); assertThat(response.getBlocksRangeEnd(), is(288L)); } |
JavaArtifactUtils { static void checkNoForbiddenChars(String artifactId) { Matcher matcher = FORBIDDEN_CHARS_PATTERN.matcher(artifactId); if (matcher.find()) { throw new IllegalArgumentException(String.format("'%s' must not have any forbidden " + "characters, but there is '%s' at index %d", artifactId, matcher.group(), matcher.start())); } } private JavaArtifactUtils(); } | @Test void checkArtifactWithNoForbiddenCharacters() { String name = "com.acme/foo:1.0"; checkNoForbiddenChars(name); }
@Test void checkArtifactWithForbiddenCharacters() { String name = "com.acme foo:1.0"; assertThrows(IllegalArgumentException.class, () -> checkNoForbiddenChars(name)); } |
ServiceArtifactId { public static ServiceArtifactId valueOf(int runtimeId, String name, String version) { checkArgument(isNotBlank(name), "name is blank: '%s'", name); checkArgument(isNotBlank(version), "version is blank: '%s'", version); return new AutoValue_ServiceArtifactId(runtimeId, name, version); } abstract int getRuntimeId(); abstract String getName(); abstract String getVersion(); static ServiceArtifactId parseFrom(String serviceArtifactId); static ServiceArtifactId newJavaId(String name, String version); static ServiceArtifactId valueOf(int runtimeId, String name, String version); static ServiceArtifactId fromProto(ArtifactId artifactId); @Override final String toString(); } | @Test void valueOf() { int runtimeId = 1; String name = "test-service"; String version = "0.1"; ServiceArtifactId id = ServiceArtifactId.valueOf(runtimeId, name, version); assertThat(id.getRuntimeId()).isEqualTo(runtimeId); assertThat(id.getName()).isEqualTo(name); assertThat(id.getVersion()).isEqualTo(version); } |
ServiceArtifactId { public static ServiceArtifactId newJavaId(String name, String version) { return valueOf(JAVA.getId(), name, version); } abstract int getRuntimeId(); abstract String getName(); abstract String getVersion(); static ServiceArtifactId parseFrom(String serviceArtifactId); static ServiceArtifactId newJavaId(String name, String version); static ServiceArtifactId valueOf(int runtimeId, String name, String version); static ServiceArtifactId fromProto(ArtifactId artifactId); @Override final String toString(); } | @Test void newJavaId() { String name = "test-service"; String version = "test-version"; ServiceArtifactId id = ServiceArtifactId.newJavaId(name, version); assertThat(id.getRuntimeId()).isEqualTo(RuntimeId.JAVA.getId()); assertThat(id.getName()).isEqualTo(name); } |
ServiceArtifactId { public static ServiceArtifactId fromProto(ArtifactId artifactId) { return valueOf(artifactId.getRuntimeId(), artifactId.getName(), artifactId.getVersion()); } abstract int getRuntimeId(); abstract String getName(); abstract String getVersion(); static ServiceArtifactId parseFrom(String serviceArtifactId); static ServiceArtifactId newJavaId(String name, String version); static ServiceArtifactId valueOf(int runtimeId, String name, String version); static ServiceArtifactId fromProto(ArtifactId artifactId); @Override final String toString(); } | @Test void fromProto() { ArtifactId artifactId = ARTIFACT_ID; ServiceArtifactId serviceArtifactId = ServiceArtifactId.fromProto(artifactId); assertThat(serviceArtifactId.getRuntimeId()).isEqualTo(artifactId.getRuntimeId()); assertThat(serviceArtifactId.getName()).isEqualTo(artifactId.getName()); assertThat(serviceArtifactId.getVersion()).isEqualTo(artifactId.getVersion()); } |
ServiceArtifactId { @Override public final String toString() { return getRuntimeId() + DELIMITER + getName() + DELIMITER + getVersion(); } abstract int getRuntimeId(); abstract String getName(); abstract String getVersion(); static ServiceArtifactId parseFrom(String serviceArtifactId); static ServiceArtifactId newJavaId(String name, String version); static ServiceArtifactId valueOf(int runtimeId, String name, String version); static ServiceArtifactId fromProto(ArtifactId artifactId); @Override final String toString(); } | @Test void toStringTest() { ServiceArtifactId id = ServiceArtifactId.valueOf(0, "full-name", "0.1"); assertThat(id.toString()).isEqualTo("0:full-name:0.1"); } |
FlatListProof { CheckedListProof<byte[]> verify() { if (size < 0 || MAX_SIZE < size) { throw new InvalidProofException(String.format("Invalid size (%s), must be in range [0; 2^56]", size)); } checkProofHashes(); if (size == 0) { return verifyEmptyListProof(); } else if (elements.isEmpty()) { return verifyEmptyRangeProof(); } else { return verifyNonEmptyListProof(); } } FlatListProof(List<ListProofElementEntry> elements,
List<ListProofHashedEntry> proof, long size); } | @Test void emptyListValidProof() { FlatListProof proof = new FlatListProof(emptyList(), emptyList(), 0L); CheckedListProof<byte[]> checked = proof.verify(); assertTrue(checked.isValid()); assertThat(checked.size()).isZero(); assertThat(checked.getIndexHash()).isEqualTo(EMPTY_LIST_INDEX_HASH); }
@Test void singletonListValidProof() { int index = 0; ListProofElementEntry element = ELEMENT_ENTRIES.get(index); long size = 1L; FlatListProof proof = new FlatListProof(singletonList(element), emptyList(), size); CheckedListProof<byte[]> checked = proof.verify(); assertTrue(checked.isValid()); assertThat(checked.size()).isEqualTo(size); byte[] e0Value = ELEMENTS.get(index); assertThat(checked.getElements()).containsExactly(entry((long) index, e0Value)); HashCode rootHash = getLeafHashCode(e0Value); HashCode expectedListHash = getProofListHash(rootHash, size); assertThat(checked.getIndexHash()).isEqualTo(expectedListHash); }
@Test void twoElementListValidProofE0() { int index = 0; long size = 2L; ListProofHashedEntry h1 = hashedEntry(1, 0); FlatListProof proof = new FlatListProofBuilder() .size(size) .addElement(ELEMENT_ENTRIES.get(index)) .addProofEntry(h1) .build(); CheckedListProof<byte[]> checked = proof.verify(); assertTrue(checked.isValid()); assertThat(checked.size()).isEqualTo(size); byte[] e0value = ELEMENTS.get(index); assertThat(checked.getElements()).containsExactly(entry((long) index, e0value)); HashCode node0Hash = getLeafHashCode(e0value); HashCode node1Hash = h1.getHash(); HashCode rootHash = getBranchHashCode(node0Hash, node1Hash); HashCode expectedListHash = getProofListHash(rootHash, size); assertThat(checked.getIndexHash()).isEqualTo(expectedListHash); }
@Test void twoElementListValidProofE1() { int index = 1; long size = 2L; ListProofHashedEntry h0 = hashedEntry(0, 0); FlatListProof proof = new FlatListProofBuilder() .size(size) .addElement(ELEMENT_ENTRIES.get(index)) .addProofEntry(h0) .build(); CheckedListProof<byte[]> checked = proof.verify(); assertTrue(checked.isValid()); assertThat(checked.size()).isEqualTo(size); byte[] e1value = ELEMENTS.get(index); assertThat(checked.getElements()).containsExactly(entry((long) index, e1value)); HashCode node0Hash = h0.getHash(); HashCode node1Hash = getLeafHashCode(e1value); HashCode rootHash = getBranchHashCode(node0Hash, node1Hash); HashCode expectedListHash = getProofListHash(rootHash, size); assertThat(checked.getIndexHash()).isEqualTo(expectedListHash); }
@Test void twoElementListValidProofFullProof() { long size = 2L; FlatListProof proof = new FlatListProofBuilder() .size(size) .addElements(ELEMENT_ENTRIES.subList(0, (int) size)) .build(); CheckedListProof<byte[]> checked = proof.verify(); assertTrue(checked.isValid()); assertThat(checked.size()).isEqualTo(size); assertThat(checked.getElements()).containsExactly( entry(0L, ELEMENTS.get(0)), entry(1L, ELEMENTS.get(1))); HashCode node0Hash = getLeafHashCode(ELEMENTS.get(0)); HashCode node1Hash = getLeafHashCode(ELEMENTS.get(1)); HashCode rootHash = getBranchHashCode(node0Hash, node1Hash); HashCode expectedListHash = getProofListHash(rootHash, size); assertThat(checked.getIndexHash()).isEqualTo(expectedListHash); }
@Test void twoElementListValidProofAt0() { FlatListProof proof = twoElementListAt0().build(); CheckedListProof<byte[]> checked = proof.verify(); assertTrue(checked.isValid()); }
@Test void threeElementListValidProofE2() { int index = 2; ListProofElementEntry elementEntry = ELEMENT_ENTRIES.get(index); long size = 3; ListProofHashedEntry h0 = hashedEntry(0, 1); FlatListProof proof = new FlatListProofBuilder() .size(size) .addElement(elementEntry) .addProofEntry(h0) .build(); CheckedListProof<byte[]> checked = proof.verify(); assertThat(checked.size()).isEqualTo(size); assertThat(checked.getElements()) .containsExactly(entry((long) index, ELEMENTS.get(index))); HashCode leafHash = getLeafHashCode(ELEMENTS.get(index)); HashCode node0Hash = h0.getHash(); HashCode node1Hash = getBranchHashCode(leafHash, null); HashCode rootHash = getBranchHashCode(node0Hash, node1Hash); HashCode expectedListHash = getProofListHash(rootHash, size); assertThat(checked.getIndexHash()).isEqualTo(expectedListHash); }
@Test void fiveElementListValidProofAt4() { FlatListProof proof = fiveElementListAt4().build(); CheckedListProof<byte[]> checked = proof.verify(); assertTrue(checked.isValid()); assertThat(checked.getElements()).containsExactly(entry(4L, ELEMENTS.get(4))); } |
ExplorerApiHelper { static List<ServiceInstanceInfo> parseServicesResponse(String json) { ServicesResponse servicesResponse = JSON.fromJson(json, ServicesResponse.class); return servicesResponse.getServices().stream() .map(ServiceInstanceState::getSpec) .collect(toList()); } private ExplorerApiHelper(); } | @Test void parseServicesResponse() { String serviceName1 = "service-name-1"; String serviceName2 = "service-name-2"; int serviceId1 = 1; int serviceId2 = 2; ServiceInstanceInfo serviceInstanceInfo1 = new ServiceInstanceInfo(serviceName1, serviceId1); ServiceInstanceInfo serviceInstanceInfo2 = new ServiceInstanceInfo(serviceName2, serviceId2); List<ServiceInstanceInfo> expected = Arrays.asList(serviceInstanceInfo1, serviceInstanceInfo2); String json = "{\n" + " \"services\": [{\n" + " \"spec\": {\n" + " \"name\": \"" + serviceName1 + "\",\n" + " \"id\": " + serviceId1 + "\n" + " },\n" + " \"status\": \"Active\"\n" + " },\n" + " {\n" + " \"spec\": {\n" + " \"name\": \"" + serviceName2 + "\",\n" + " \"id\": " + serviceId2 + "\n" + " },\n" + " \"status\": \"Active\"\n" + " }\n" + " ]\n" + "}"; List<ServiceInstanceInfo> actual = ExplorerApiHelper.parseServicesResponse(json); assertThat(actual, contains(expected.toArray())); } |
ProofHashes { public static void checkSha256Hash(HashCode hash) { int size = hash.bits(); if (size != Hashing.DEFAULT_HASH_SIZE_BITS) { String message = String.format("Invalid hash size (%s), must be 256 bits", size); throw new InvalidProofException(message); } } private ProofHashes(); static void checkSha256Hash(HashCode hash); } | @Test void checkValidSha256Hash() { HashCode hash = HashCode.fromBytes(new byte[32]); assertDoesNotThrow(() -> ProofHashes.checkSha256Hash(hash)); } |
DbKey implements Comparable<DbKey> { public static DbKey fromBytes(byte[] rawDbKey) { return new DbKey(rawDbKey); } private DbKey(byte[] rawDbKey); private DbKey(DbKey.Type nodeType, byte[] keySlice, int numSignificantBits); static DbKey fromBytes(byte[] rawDbKey); static DbKey newLeafKey(ByteString key); static DbKey newLeafKey(byte[] keySlice); static DbKey newBranchKey(byte[] keySlice, int numSignificantBits); Type getNodeType(); byte[] getKeySlice(); int getNumSignificantBits(); byte[] getRawDbKey(); KeyBitSet keyBits(); DbKey commonPrefix(DbKey other); boolean isPrefixOf(DbKey other); @Override boolean equals(Object o); @Override int hashCode(); @Override int compareTo(DbKey other); static final int KEY_SIZE; static final int KEY_SIZE_BITS; static final int DB_KEY_SIZE; } | @Test void throwsIfNull() { assertThrows(NullPointerException.class, () -> DbKey.fromBytes(null)); }
@Test void throwsIfInvalidNodeTypeCode() { byte[] rawDbKey = createDbKey(2, bytes("a"), 8); assertThrows(IllegalArgumentException.class, () -> { DbKey dbKey = DbKey.fromBytes(rawDbKey); }); }
@Test void throwsIfLeafHasInvalidSize() { int invalidNumBits = 10; byte[] rawDbKey = createDbKey(Type.LEAF.code, bytes("a"), invalidNumBits); assertThrows(IllegalArgumentException.class, () -> { DbKey dbKey = DbKey.fromBytes(rawDbKey); }); }
@Test void throwsIfBranchKeySliceHasBitsAfterSignificantPart0Bits() { int numSignificantBits = 0; byte[] rawDbKey = createDbKey(Type.BRANCH.code, bytes(0x01), numSignificantBits); assertThrows(IllegalArgumentException.class, () -> { DbKey dbKey = DbKey.fromBytes(rawDbKey); }); }
@Test void throwsIfBranchKeySliceHasBitsAfterSignificantPart1Bit() { int numSignificantBits = 1; byte[] rawDbKey = createDbKey(Type.BRANCH.code, bytes(0x03), numSignificantBits); assertThrows(IllegalArgumentException.class, () -> { DbKey dbKey = DbKey.fromBytes(rawDbKey); }); }
@Test void throwsIfBranchKeySliceHasBitsAfterSignificantPart7Bit() { int numSignificantBits = 7; byte[] rawDbKey = createDbKey(Type.BRANCH.code, bytes(0x80), numSignificantBits); assertThrows(IllegalArgumentException.class, () -> { DbKey dbKey = DbKey.fromBytes(rawDbKey); }); }
@Test void throwsIfBranchKeySliceHasBitsAfterSignificantPart8Bit() { int numSignificantBits = 8; byte[] rawDbKey = createDbKey(Type.BRANCH.code, bytes(0xFF, 0x01), numSignificantBits); assertThrows(IllegalArgumentException.class, () -> { DbKey dbKey = DbKey.fromBytes(rawDbKey); }); }
@Test void throwsIfBranchKeySliceHasBitsAfterSignificantPart12Bit() { int numSignificantBits = 12; byte[] rawDbKey = createDbKey(Type.BRANCH.code, bytes(0xFF, 0x1F), numSignificantBits); assertThrows(IllegalArgumentException.class, () -> { DbKey dbKey = DbKey.fromBytes(rawDbKey); }); }
@Test void throwsIfBranchKeySliceHasBitsAfterSignificantPart16Bit() { int numSignificantBits = 16; byte[] rawDbKey = createDbKey(Type.BRANCH.code, bytes(0xFF, 0xFF, 0x01), numSignificantBits); assertThrows(IllegalArgumentException.class, () -> { DbKey dbKey = DbKey.fromBytes(rawDbKey); }); } |
ExonumIterables { static <T> OptionalInt indexOf(Iterable<T> list, Predicate<? super T> p) { int i = Iterables.indexOf(list, p::test); if (i == -1) { return OptionalInt.empty(); } return OptionalInt.of(i); } private ExonumIterables(); } | @Test void indexOfFindsTheFirst() { List<Integer> l = ImmutableList.of(-1, 1, 2, 3); Predicate<Integer> positiveInt = i -> i > 0; assertThat(ExonumIterables.indexOf(l, positiveInt), equalTo(OptionalInt.of(1))); }
@Test void indexOfNoMatches() { List<Integer> l = ImmutableList.of(-1, -2, -3); Predicate<Integer> positiveInt = i -> i > 0; assertThat(ExonumIterables.indexOf(l, positiveInt), equalTo(OptionalInt.empty())); } |
UncheckedFlatMapProof implements UncheckedMapProof { @Override public CheckedMapProof check() { MapProofStatus orderCheckResult = orderCheck(); if (orderCheckResult != MapProofStatus.CORRECT) { return CheckedFlatMapProof.invalid(orderCheckResult); } if (containsInvalidHashes()) { return CheckedFlatMapProof.invalid(MapProofStatus.INVALID_HASH_SIZE); } if (prefixesIncluded()) { return CheckedFlatMapProof.invalid(MapProofStatus.EMBEDDED_PATH); } if (isEmptyProof()) { return checkEmptyProof(); } else if (isSingletonProof()) { return checkSingletonProof(); } else { return checkProof(); } } UncheckedFlatMapProof(
List<MapProofEntry> proof,
List<MapEntry<ByteString, ByteString>> entries,
List<byte[]> missingKeys); @Override CheckedMapProof check(); } | @Test void mapProofShouldBeCorrect() { DbKey firstDbKey = DbKeyTestUtils.branchKeyFromPrefix("101100"); ByteString valueKey = DbKeyTestUtils.keyByteStringFromString("101110"); DbKey thirdDbKey = DbKeyTestUtils.branchKeyFromPrefix("1011111"); MapEntry<ByteString, ByteString> leaf = createMapEntry(valueKey, FIRST_VALUE); List<MapProofEntry> branches = Arrays.asList( createMapProofEntry(firstDbKey), createMapProofEntry(thirdDbKey) ); UncheckedMapProof uncheckedFlatMapProof = new UncheckedFlatMapProof(branches, singletonList(leaf), emptyList()); CheckedMapProof checkedMapProof = uncheckedFlatMapProof.check(); MapEntry<ByteString, ByteString> expectedEntry = MapEntry.valueOf(valueKey, FIRST_VALUE); assertThat(checkedMapProof.getEntries(), equalTo(singleton(expectedEntry))); assertTrue(checkedMapProof.containsKey(valueKey)); assertThat(checkedMapProof.get(valueKey), equalTo(FIRST_VALUE)); }
@Test void mapProofWithSeveralLeafsShouldBeCorrect() { ByteString firstKey = DbKeyTestUtils.keyByteStringFromString("0011_0101"); ByteString secondKey = DbKeyTestUtils.keyByteStringFromString("0011_0110"); DbKey thirdDbKey = DbKeyTestUtils.branchKeyFromPrefix("0100_0000"); ByteString fourthKey = DbKeyTestUtils.keyByteStringFromString("1000_1101"); List<MapEntry<ByteString, ByteString>> leaves = Arrays.asList( createMapEntry(firstKey, FIRST_VALUE), createMapEntry(secondKey, SECOND_VALUE), createMapEntry(fourthKey, THIRD_VALUE) ); UncheckedMapProof uncheckedFlatMapProof = new UncheckedFlatMapProof( singletonList(createMapProofEntry(thirdDbKey)), leaves, emptyList()); CheckedMapProof checkedMapProof = uncheckedFlatMapProof.check(); Set<MapEntry<ByteString, ByteString>> actualCheckedEntries = checkedMapProof.getEntries(); assertThat(actualCheckedEntries, containsInAnyOrder(leaves.toArray())); assertTrue(checkedMapProof.containsKey(firstKey)); assertThat(checkedMapProof.get(firstKey), equalTo(FIRST_VALUE)); assertThat(checkedMapProof.get(secondKey), equalTo(SECOND_VALUE)); assertThat(checkedMapProof.get(fourthKey), equalTo(THIRD_VALUE)); assertThrows(IllegalArgumentException.class, () -> checkedMapProof.containsKey(ByteString.copyFromUtf8("not required key"))); }
@Test void mapProofWithEqualEntriesOrderShouldBeInvalid() { DbKey firstDbKey = DbKeyTestUtils.branchKeyFromPrefix("101100"); DbKey secondKey = DbKeyTestUtils.branchKeyFromPrefix("101100"); List<MapProofEntry> entries = Arrays.asList( createMapProofEntry(firstDbKey), createMapProofEntry(secondKey) ); UncheckedMapProof uncheckedFlatMapProof = new UncheckedFlatMapProof(entries, emptyList(), emptyList()); CheckedMapProof checkedMapProof = uncheckedFlatMapProof.check(); assertThat(checkedMapProof.getProofStatus(), equalTo(MapProofStatus.DUPLICATE_PATH)); }
@Test void mapProofWithAbsentKeyShouldBeCorrect() { DbKey firstDbKey = DbKeyTestUtils.branchKeyFromPrefix("101100"); ByteString valueKey = DbKeyTestUtils.keyByteStringFromString("101110"); byte[] absentKey = DbKeyTestUtils.keyFromString("101111"); UncheckedMapProof uncheckedFlatMapProof = new UncheckedFlatMapProof( singletonList(createMapProofEntry(firstDbKey)), singletonList(createMapEntry(valueKey, FIRST_VALUE)), singletonList(absentKey)); CheckedMapProof checkedMapProof = uncheckedFlatMapProof.check(); assertThat(checkedMapProof.getProofStatus(), equalTo(MapProofStatus.CORRECT)); }
@Test void mapProofWithInvalidOrderShouldBeIncorrect() { DbKey firstDbKey = DbKeyTestUtils.branchKeyFromPrefix("10"); DbKey secondDbKey = DbKeyTestUtils.branchKeyFromPrefix("01"); UncheckedMapProof uncheckedFlatMapProof = new UncheckedFlatMapProof( Arrays.asList(createMapProofEntry(firstDbKey), createMapProofEntry(secondDbKey)), emptyList(), emptyList()); CheckedMapProof checkedMapProof = uncheckedFlatMapProof.check(); assertThat(checkedMapProof.getProofStatus(), equalTo(MapProofStatus.INVALID_ORDER)); }
@Test void mapProofWithSingleBranchProofEntryShouldBeInvalid() { DbKey firstDbKey = DbKeyTestUtils.branchKeyFromPrefix("1011111"); byte[] absentKey = DbKeyTestUtils.keyFromString("101111"); UncheckedMapProof uncheckedFlatMapProof = new UncheckedFlatMapProof( singletonList(createMapProofEntry(firstDbKey)), emptyList(), singletonList(absentKey)); CheckedMapProof checkedMapProof = uncheckedFlatMapProof.check(); assertThat(checkedMapProof.getProofStatus(), equalTo(MapProofStatus.NON_TERMINAL_NODE)); }
@Test void mapProofWithSingleLeafProofEntryShouldBeCorrect() { DbKey firstDbKey = DbKeyTestUtils.leafKeyFromPrefix("1011111"); byte[] absentKey = DbKeyTestUtils.keyFromString("101111"); UncheckedMapProof uncheckedFlatMapProof = new UncheckedFlatMapProof( singletonList(createMapProofEntry(firstDbKey)), emptyList(), singletonList(absentKey)); CheckedMapProof checkedMapProof = uncheckedFlatMapProof.check(); assertThat(checkedMapProof.getProofStatus(), equalTo(MapProofStatus.CORRECT)); }
@Test void mapProofWithIncludedPrefixesShouldBeInvalid() { DbKey firstDbKey = DbKeyTestUtils.branchKeyFromPrefix("01"); DbKey secondDbKey = DbKeyTestUtils.branchKeyFromPrefix("11"); byte[] absentKey = DbKeyTestUtils.keyFromString("111111"); UncheckedMapProof uncheckedFlatMapProof = new UncheckedFlatMapProof( Arrays.asList( createMapProofEntry(firstDbKey), createMapProofEntry(secondDbKey)), emptyList(), singletonList(absentKey)); CheckedMapProof checkedMapProof = uncheckedFlatMapProof.check(); assertThat(checkedMapProof.getProofStatus(), equalTo(MapProofStatus.EMBEDDED_PATH)); }
@Test void mapProofWithIncludedBranchPrefixesShouldBeInvalid() { DbKey firstDbKey = DbKeyTestUtils.branchKeyFromPrefix("01"); DbKey secondDbKey = DbKeyTestUtils.branchKeyFromPrefix("011"); byte[] absentKey = DbKeyTestUtils.keyFromString("111111"); UncheckedMapProof uncheckedFlatMapProof = new UncheckedFlatMapProof( Arrays.asList( createMapProofEntry(firstDbKey), createMapProofEntry(secondDbKey)), emptyList(), singletonList(absentKey)); CheckedMapProof checkedMapProof = uncheckedFlatMapProof.check(); assertThat(checkedMapProof.getProofStatus(), equalTo(MapProofStatus.EMBEDDED_PATH)); } |
AbstractNonStreamingHashFunction extends AbstractHashFunction { @Override public Hasher newHasher() { return newHasher(32); } @Override Hasher newHasher(); @Override Hasher newHasher(int expectedInputSize); @Override HashCode hashInt(int input); @Override HashCode hashLong(long input); @Override HashCode hashUnencodedChars(CharSequence input); @Override HashCode hashString(CharSequence input, Charset charset); @Override abstract HashCode hashBytes(byte[] input, int off, int len); @Override HashCode hashBytes(ByteBuffer input); } | @Test void testExhaustive() { List<Hasher> hashers = ImmutableList.of( new StreamingVersion().newHasher(), new StreamingVersion().newHasher(52), new NonStreamingVersion().newHasher(), new NonStreamingVersion().newHasher(123)); Random random = new Random(0); for (int i = 0; i < 200; i++) { RandomHasherAction.pickAtRandom(random).performAction(random, hashers); } HashCode[] codes = new HashCode[hashers.size()]; for (int i = 0; i < hashers.size(); i++) { codes[i] = hashers.get(i).hash(); } for (int i = 1; i < codes.length; i++) { assertEquals(codes[i - 1], codes[i]); } } |
AbstractStreamingHasher extends AbstractHasher { @Override public final HashCode hash() { munch(); buffer.flip(); if (buffer.remaining() > 0) { processRemaining(buffer); buffer.position(buffer.limit()); } return makeHash(); } protected AbstractStreamingHasher(int chunkSize); protected AbstractStreamingHasher(int chunkSize, int bufferSize); @Override final Hasher putBytes(byte[] bytes, int off, int len); @Override final Hasher putBytes(ByteBuffer readBuffer); @Override final Hasher putByte(byte b); @Override final Hasher putShort(short s); @Override final Hasher putChar(char c); @Override final Hasher putInt(int i); @Override final Hasher putLong(long l); @Override final HashCode hash(); } | @Test void testFloat() { Sink sink = new Sink(4); sink.putFloat(Float.intBitsToFloat(0x04030201)); HashCode unused = sink.hash(); sink.assertInvariants(4); sink.assertBytes(new byte[]{1, 2, 3, 4}); }
@Test void testDouble() { Sink sink = new Sink(8); sink.putDouble(Double.longBitsToDouble(0x0807060504030201L)); HashCode unused = sink.hash(); sink.assertInvariants(8); sink.assertBytes(new byte[]{1, 2, 3, 4, 5, 6, 7, 8}); } |
AbstractStreamingHasher extends AbstractHasher { @Override public final Hasher putBytes(byte[] bytes, int off, int len) { return putBytesInternal(ByteBuffer.wrap(bytes, off, len).order(ByteOrder.LITTLE_ENDIAN)); } protected AbstractStreamingHasher(int chunkSize); protected AbstractStreamingHasher(int chunkSize, int bufferSize); @Override final Hasher putBytes(byte[] bytes, int off, int len); @Override final Hasher putBytes(ByteBuffer readBuffer); @Override final Hasher putByte(byte b); @Override final Hasher putShort(short s); @Override final Hasher putChar(char c); @Override final Hasher putInt(int i); @Override final Hasher putLong(long l); @Override final HashCode hash(); } | @Test void testCorrectExceptions() { Sink sink = new Sink(4); assertThrows(IndexOutOfBoundsException.class, () -> sink.putBytes(new byte[8], -1, 4)); assertThrows(IndexOutOfBoundsException.class, () -> sink.putBytes(new byte[8], 0, 16)); assertThrows(IndexOutOfBoundsException.class, () -> sink.putBytes(new byte[8], 0, -1)); } |
MessageDigestHashFunction extends AbstractHashFunction implements Serializable { @Override public String toString() { return toString; } MessageDigestHashFunction(String algorithmName, String toString); MessageDigestHashFunction(String algorithmName, int bytes, String toString); @Override int bits(); @Override String toString(); @Override Hasher newHasher(); } | @Test void testToString() { assertEquals("Hashing.sha256()", Hashing.sha256().toString()); assertEquals("Hashing.sha512()", Hashing.sha512().toString()); } |
FakeServiceModule extends AbstractServiceModule { @Override protected void configure() { bind(Service.class).to(FakeService.class) .in(Singleton.class); } } | @Test void configure() { Injector injector = Guice.createInjector(new AbstractModule() { @Override protected void configure() { bind(ServiceInstanceSpec.class).toInstance(ServiceInstanceSpec.newInstance("test", 1, ServiceArtifactId.newJavaId("a/b", "1"))); } }, new FakeServiceModule()); Service instance = injector.getInstance(Service.class); assertNotNull(instance); assertThat(instance, instanceOf(FakeService.class)); } |
AbstractByteHasher extends AbstractHasher { @Override public Hasher putShort(short s) { scratch.putShort(s); return update(Shorts.BYTES); } @Override Hasher putByte(byte b); @Override Hasher putBytes(byte[] bytes); @Override Hasher putBytes(byte[] bytes, int off, int len); @Override Hasher putBytes(ByteBuffer bytes); @Override Hasher putShort(short s); @Override Hasher putInt(int i); @Override Hasher putLong(long l); @Override Hasher putChar(char c); } | @Test void testShort() { TestHasher hasher = new TestHasher(); hasher.putShort((short) 0x0201); hasher.assertBytes(new byte[]{1, 2}); } |
AbstractByteHasher extends AbstractHasher { @Override public Hasher putInt(int i) { scratch.putInt(i); return update(Ints.BYTES); } @Override Hasher putByte(byte b); @Override Hasher putBytes(byte[] bytes); @Override Hasher putBytes(byte[] bytes, int off, int len); @Override Hasher putBytes(ByteBuffer bytes); @Override Hasher putShort(short s); @Override Hasher putInt(int i); @Override Hasher putLong(long l); @Override Hasher putChar(char c); } | @Test void testInt() { TestHasher hasher = new TestHasher(); hasher.putInt(0x04030201); hasher.assertBytes(new byte[]{1, 2, 3, 4}); } |
AbstractByteHasher extends AbstractHasher { @Override public Hasher putLong(long l) { scratch.putLong(l); return update(Longs.BYTES); } @Override Hasher putByte(byte b); @Override Hasher putBytes(byte[] bytes); @Override Hasher putBytes(byte[] bytes, int off, int len); @Override Hasher putBytes(ByteBuffer bytes); @Override Hasher putShort(short s); @Override Hasher putInt(int i); @Override Hasher putLong(long l); @Override Hasher putChar(char c); } | @Test void testLong() { TestHasher hasher = new TestHasher(); hasher.putLong(0x0807060504030201L); hasher.assertBytes(new byte[]{1, 2, 3, 4, 5, 6, 7, 8}); } |
AbstractByteHasher extends AbstractHasher { @Override public Hasher putChar(char c) { scratch.putChar(c); return update(Chars.BYTES); } @Override Hasher putByte(byte b); @Override Hasher putBytes(byte[] bytes); @Override Hasher putBytes(byte[] bytes, int off, int len); @Override Hasher putBytes(ByteBuffer bytes); @Override Hasher putShort(short s); @Override Hasher putInt(int i); @Override Hasher putLong(long l); @Override Hasher putChar(char c); } | @Test void testChar() { TestHasher hasher = new TestHasher(); hasher.putChar((char) 0x0201); hasher.assertBytes(new byte[]{1, 2}); } |
AbstractByteHasher extends AbstractHasher { @Override public Hasher putBytes(byte[] bytes) { checkNotNull(bytes); update(bytes); return this; } @Override Hasher putByte(byte b); @Override Hasher putBytes(byte[] bytes); @Override Hasher putBytes(byte[] bytes, int off, int len); @Override Hasher putBytes(ByteBuffer bytes); @Override Hasher putShort(short s); @Override Hasher putInt(int i); @Override Hasher putLong(long l); @Override Hasher putChar(char c); } | @Test void testString() { Random random = new Random(); for (int i = 0; i < 100; i++) { byte[] bytes = new byte[64]; random.nextBytes(bytes); String s = new String(bytes, UTF_16LE); assertEquals( new TestHasher().putUnencodedChars(s).hash(), new TestHasher().putBytes(s.getBytes(UTF_16LE)).hash()); assertEquals( new TestHasher().putUnencodedChars(s).hash(), new TestHasher().putString(s, UTF_16LE).hash()); } }
@Test void testCorrectExceptions() { TestHasher hasher = new TestHasher(); assertThrows(IndexOutOfBoundsException.class, () -> hasher.putBytes(new byte[8], -1, 4)); assertThrows(IndexOutOfBoundsException.class, () -> hasher.putBytes(new byte[8], 0, 16)); assertThrows(IndexOutOfBoundsException.class, () -> hasher.putBytes(new byte[8], 0, -1)); } |
Hashing { public static HashFunction defaultHashFunction() { return sha256(); } private Hashing(); static HashFunction sha256(); static HashFunction defaultHashFunction(); static HashFunction sha384(); static HashFunction sha512(); static final int DEFAULT_HASH_SIZE_BYTES; static final int DEFAULT_HASH_SIZE_BITS; } | @Test void testGetHashOfEmptyArray() { HashFunction f = Hashing.defaultHashFunction(); assertThat(f.hashBytes(bytes()), equalTo(ZERO_HASH_CODE)); }
@Test void testGetHashOfEmptyByteBuffer() { HashFunction f = Hashing.defaultHashFunction(); assertThat(f.hashBytes(ByteBuffer.allocate(0)), equalTo(ZERO_HASH_CODE)); } |
Hashing { public static HashFunction sha256() { return Sha256Holder.SHA_256; } private Hashing(); static HashFunction sha256(); static HashFunction defaultHashFunction(); static HashFunction sha384(); static HashFunction sha512(); static final int DEFAULT_HASH_SIZE_BYTES; static final int DEFAULT_HASH_SIZE_BITS; } | @Test void testSha256() { HashTestUtils.checkAvalanche(Hashing.sha256(), 100, 0.4); HashTestUtils.checkNo2BitCharacteristics(Hashing.sha256()); HashTestUtils.checkNoFunnels(Hashing.sha256()); HashTestUtils.assertInvariants(Hashing.sha256()); assertEquals("Hashing.sha256()", Hashing.sha256().toString()); } |
Hashing { public static HashFunction sha384() { return Sha384Holder.SHA_384; } private Hashing(); static HashFunction sha256(); static HashFunction defaultHashFunction(); static HashFunction sha384(); static HashFunction sha512(); static final int DEFAULT_HASH_SIZE_BYTES; static final int DEFAULT_HASH_SIZE_BITS; } | @Test void testSha384() { HashTestUtils.checkAvalanche(Hashing.sha384(), 100, 0.4); HashTestUtils.checkNo2BitCharacteristics(Hashing.sha384()); HashTestUtils.checkNoFunnels(Hashing.sha384()); HashTestUtils.assertInvariants(Hashing.sha384()); assertEquals("Hashing.sha384()", Hashing.sha384().toString()); } |
ApiController { private void submitIncrementCounter(RoutingContext rc) { MultiMap parameters = rc.request().params(); long seed = getRequiredParameter(parameters, "seed", Long::parseLong); String counterName = getRequiredParameter(parameters, COUNTER_NAME_PARAM, identity()); HashCode txHash = service.submitIncrementCounter(seed, counterName); replyTxSubmitted(rc, txHash); } ApiController(QaService service); } | @Test void submitIncrementCounter(VertxTestContext context) { long seed = 1L; String counterName = "counter1"; MultiMap params = multiMap("seed", Long.toString(seed), "counterName", counterName); when(qaService.submitIncrementCounter(eq(seed), eq(counterName))) .thenReturn(EXPECTED_TX_HASH); post(SUBMIT_INCREMENT_COUNTER_TX_PATH) .sendForm(params, checkCreatedTransaction(context, EXPECTED_TX_HASH)); } |
Hashing { public static HashFunction sha512() { return Sha512Holder.SHA_512; } private Hashing(); static HashFunction sha256(); static HashFunction defaultHashFunction(); static HashFunction sha384(); static HashFunction sha512(); static final int DEFAULT_HASH_SIZE_BYTES; static final int DEFAULT_HASH_SIZE_BITS; } | @Test void testSha512() { HashTestUtils.checkAvalanche(Hashing.sha512(), 100, 0.4); HashTestUtils.checkNo2BitCharacteristics(Hashing.sha512()); HashTestUtils.checkNoFunnels(Hashing.sha512()); HashTestUtils.assertInvariants(Hashing.sha512()); assertEquals("Hashing.sha512()", Hashing.sha512().toString()); } |
HashCode { public static HashCode fromInt(int hash) { return new IntHashCode(hash); } HashCode(); abstract int bits(); abstract int asInt(); abstract long asLong(); abstract long padToLong(); abstract byte[] asBytes(); @CanIgnoreReturnValue int writeBytesTo(byte[] dest, int offset, int maxLength); static HashCode fromInt(int hash); static HashCode fromLong(long hash); static HashCode fromBytes(byte[] bytes); static HashCode fromString(String string); @Override final boolean equals(@Nullable Object object); @Override final int hashCode(); @Override final String toString(); } | @Test void testFromInt() { for (ExpectedHashCode expected : expectedHashCodes) { if (expected.bytes.length == 4) { HashCode fromInt = HashCode.fromInt(expected.asInt); assertExpectedHashCode(expected, fromInt); } } } |
HashCode { public static HashCode fromLong(long hash) { return new LongHashCode(hash); } HashCode(); abstract int bits(); abstract int asInt(); abstract long asLong(); abstract long padToLong(); abstract byte[] asBytes(); @CanIgnoreReturnValue int writeBytesTo(byte[] dest, int offset, int maxLength); static HashCode fromInt(int hash); static HashCode fromLong(long hash); static HashCode fromBytes(byte[] bytes); static HashCode fromString(String string); @Override final boolean equals(@Nullable Object object); @Override final int hashCode(); @Override final String toString(); } | @Test void testFromLong() { for (ExpectedHashCode expected : expectedHashCodes) { if (expected.bytes.length == 8) { HashCode fromLong = HashCode.fromLong(expected.asLong); assertExpectedHashCode(expected, fromLong); } } } |
HashCode { public static HashCode fromBytes(byte[] bytes) { checkArgument(bytes.length >= 1, "A HashCode must contain at least 1 byte."); return fromBytesNoCopy(bytes.clone()); } HashCode(); abstract int bits(); abstract int asInt(); abstract long asLong(); abstract long padToLong(); abstract byte[] asBytes(); @CanIgnoreReturnValue int writeBytesTo(byte[] dest, int offset, int maxLength); static HashCode fromInt(int hash); static HashCode fromLong(long hash); static HashCode fromBytes(byte[] bytes); static HashCode fromString(String string); @Override final boolean equals(@Nullable Object object); @Override final int hashCode(); @Override final String toString(); } | @Test void testFromBytes() { for (ExpectedHashCode expected : expectedHashCodes) { HashCode fromBytes = HashCode.fromBytes(expected.bytes); assertExpectedHashCode(expected, fromBytes); } } |
HashCode { public abstract long padToLong(); HashCode(); abstract int bits(); abstract int asInt(); abstract long asLong(); abstract long padToLong(); abstract byte[] asBytes(); @CanIgnoreReturnValue int writeBytesTo(byte[] dest, int offset, int maxLength); static HashCode fromInt(int hash); static HashCode fromLong(long hash); static HashCode fromBytes(byte[] bytes); static HashCode fromString(String string); @Override final boolean equals(@Nullable Object object); @Override final int hashCode(); @Override final String toString(); } | @Test void testPadToLong() { assertEquals(0x1111111111111111L, HashCode.fromLong(0x1111111111111111L).padToLong()); assertEquals(0x9999999999999999L, HashCode.fromLong(0x9999999999999999L).padToLong()); assertEquals(0x0000000011111111L, HashCode.fromInt(0x11111111).padToLong()); assertEquals(0x0000000099999999L, HashCode.fromInt(0x99999999).padToLong()); } |
HashCode { @Override public final String toString() { byte[] bytes = getBytesInternal(); StringBuilder sb = new StringBuilder(2 * bytes.length); for (byte b : bytes) { sb.append(hexDigits[(b >> 4) & 0xf]).append(hexDigits[b & 0xf]); } return sb.toString(); } HashCode(); abstract int bits(); abstract int asInt(); abstract long asLong(); abstract long padToLong(); abstract byte[] asBytes(); @CanIgnoreReturnValue int writeBytesTo(byte[] dest, int offset, int maxLength); static HashCode fromInt(int hash); static HashCode fromLong(long hash); static HashCode fromBytes(byte[] bytes); static HashCode fromString(String string); @Override final boolean equals(@Nullable Object object); @Override final int hashCode(); @Override final String toString(); } | @Test void testToString() { byte[] data = new byte[]{127, -128, 5, -1, 14}; assertEquals("7f8005ff0e", HashCode.fromBytes(data).toString()); assertEquals("7f8005ff0e", base16().lowerCase().encode(data)); } |
HashCode { public static HashCode fromString(String string) { checkArgument( string.length() >= 2, "input string (%s) must have at least 2 characters", string); checkArgument( string.length() % 2 == 0, "input string (%s) must have an even number of characters", string); byte[] bytes = new byte[string.length() / 2]; for (int i = 0; i < string.length(); i += 2) { int ch1 = decode(string.charAt(i)) << 4; int ch2 = decode(string.charAt(i + 1)); bytes[i / 2] = (byte) (ch1 + ch2); } return fromBytesNoCopy(bytes); } HashCode(); abstract int bits(); abstract int asInt(); abstract long asLong(); abstract long padToLong(); abstract byte[] asBytes(); @CanIgnoreReturnValue int writeBytesTo(byte[] dest, int offset, int maxLength); static HashCode fromInt(int hash); static HashCode fromLong(long hash); static HashCode fromBytes(byte[] bytes); static HashCode fromString(String string); @Override final boolean equals(@Nullable Object object); @Override final int hashCode(); @Override final String toString(); } | @Test void testFromStringFailsWithInvalidHexChar() { assertThrows(IllegalArgumentException.class, () -> HashCode.fromString("7f8005ff0z")); }
@Test void testFromStringFailsWithShortInputs() { assertThrows(IllegalArgumentException.class, () -> HashCode.fromString("")); assertThrows(IllegalArgumentException.class, () -> HashCode.fromString("7")); HashCode unused = HashCode.fromString("7f"); }
@Test void testFromStringFailsWithOddLengthInput() { assertThrows(IllegalArgumentException.class, () -> HashCode.fromString("7f8")); } |
ApiController { private void submitUnknownTx(RoutingContext rc) { HashCode txHash = service.submitUnknownTx(); replyTxSubmitted(rc, txHash); } ApiController(QaService service); } | @Test void submitUnknown(VertxTestContext context) { when(qaService.submitUnknownTx()) .thenReturn(EXPECTED_TX_HASH); post(SUBMIT_UNKNOWN_TX_PATH) .send(checkCreatedTransaction(context, EXPECTED_TX_HASH)); } |
ForgotPasswordViewModel { public boolean isValidateLogin() { boolean valid = true; if (mLoginValidator != null && !mLoginValidator.isValid(mLogin.get())) { mLoginError.set(mViewAccess.getLoginErrorMessage()); valid = false; } else { mLoginError.set(null); } return valid; } @Inject ForgotPasswordViewModel(); boolean isValidateLogin(); final ObservableString mLogin; final ObservableString mLoginError; } | @Test public void validateLogin_Success() throws Exception { when(mModel.mLoginValidator.isValid(any())).thenReturn(true); assertThat(mModel.isValidateLogin(), is(true)); assertThat(Strings.isNullOrEmpty(mModel.mLoginError.get()), is(true)); }
@Test public void validateLogin_Error() throws Exception { when(mModel.mLoginValidator.isValid(any())).thenReturn(false); when(mModel.mViewAccess.getLoginErrorMessage()).thenReturn("error"); assertThat(mModel.isValidateLogin(), is(false)); assertThat(Strings.isNullOrEmpty(mModel.mLoginError.get()), is(false)); } |
RegisterViewModel extends BaseViewModel { protected boolean isPasswordValid() { boolean valid = true; if (mPasswordValidator != null && !mPasswordValidator.isValid(mPassword.get())) { mPasswordError.set(mViewAccess.getPasswordErrorMessage()); valid = false; } else { mPasswordError.set(null); } return valid; } @Inject RegisterViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mFirstName; final ObservableString mLastName; final ObservableString mPassword; final ObservableString mConfirmPassword; final ObservableString mLoginError; final ObservableString mFirstNameError; final ObservableString mLastNameError; final ObservableString mPasswordError; final ObservableString mConfirmPasswordError; } | @Test public void validatePassword_Error() throws Exception { when(mModel.mPasswordValidator.isValid(any())).thenReturn(false); when(mModel.mViewAccess.getPasswordErrorMessage()).thenReturn("error"); assertThat(mModel.isPasswordValid(), is(false)); assertThat(Strings.isNullOrEmpty(mModel.mPasswordError.get()), is(false)); }
@Test public void validatePassword_Success() throws Exception { when(mModel.mPasswordValidator.isValid(any())).thenReturn(true); assertThat(mModel.isPasswordValid(), is(true)); assertThat(Strings.isNullOrEmpty(mModel.mPasswordError.get()), is(true)); } |
RegisterViewModel extends BaseViewModel { protected boolean isConfirmPasswordValid() { boolean valid = true; if (!Strings.isNullOrEmpty(mPassword.get()) && !Strings.isNullOrEmpty(mConfirmPassword.get()) && mPassword.get().equals(mConfirmPassword.get())) { mConfirmPasswordError.set(null); } else { mConfirmPasswordError.set(mViewAccess.getConfirmPasswordErrorMessage()); valid = false; } return valid; } @Inject RegisterViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mFirstName; final ObservableString mLastName; final ObservableString mPassword; final ObservableString mConfirmPassword; final ObservableString mLoginError; final ObservableString mFirstNameError; final ObservableString mLastNameError; final ObservableString mPasswordError; final ObservableString mConfirmPasswordError; } | @Test public void validatePasswordConfirm_Success() throws Exception { String password = "pass123"; mModel.mPassword.set(password); mModel.mConfirmPassword.set(password); assertThat(mModel.isConfirmPasswordValid(), is(true)); assertThat(Strings.isNullOrEmpty(mModel.mConfirmPasswordError.get()), is(true)); }
@Test public void validatePasswordConfirm_Error() throws Exception { when(mModel.mViewAccess.getConfirmPasswordErrorMessage()).thenReturn("error"); String password = "pass123"; mModel.mPassword.set(password); mModel.mConfirmPassword.set(""); assertThat(mModel.isConfirmPasswordValid(), is(false)); assertThat(Strings.isNullOrEmpty(mModel.mConfirmPasswordError.get()), is(false)); } |
RegisterViewModel extends BaseViewModel { protected void setLoginValidator(@Nullable Validator validator) { mLoginValidator = validator; } @Inject RegisterViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mFirstName; final ObservableString mLastName; final ObservableString mPassword; final ObservableString mConfirmPassword; final ObservableString mLoginError; final ObservableString mFirstNameError; final ObservableString mLastNameError; final ObservableString mPasswordError; final ObservableString mConfirmPasswordError; } | @Test public void setLoginValidator_Correct() throws Exception { Validator validator = new EmailValidator(); mModel.setLoginValidator(validator); assertThat(mModel.mLoginValidator, is(validator)); } |
RegisterViewModel extends BaseViewModel { protected void setFirstNameValidator(@Nullable Validator validator) { mFirstNameValidator = validator; } @Inject RegisterViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mFirstName; final ObservableString mLastName; final ObservableString mPassword; final ObservableString mConfirmPassword; final ObservableString mLoginError; final ObservableString mFirstNameError; final ObservableString mLastNameError; final ObservableString mPasswordError; final ObservableString mConfirmPasswordError; } | @Test public void setFirstNameValidator_Correct() throws Exception { Validator validator = new EmailValidator(); mModel.setFirstNameValidator(validator); assertThat(mModel.mFirstNameValidator, is(validator)); } |
RegisterViewModel extends BaseViewModel { protected void setLastNameValidator(@Nullable Validator validator) { mLastNameValidator = validator; } @Inject RegisterViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mFirstName; final ObservableString mLastName; final ObservableString mPassword; final ObservableString mConfirmPassword; final ObservableString mLoginError; final ObservableString mFirstNameError; final ObservableString mLastNameError; final ObservableString mPasswordError; final ObservableString mConfirmPasswordError; } | @Test public void setLastNameValidator_Correct() throws Exception { Validator validator = new EmailValidator(); mModel.setLastNameValidator(validator); assertThat(mModel.mLastNameValidator, is(validator)); } |
RegisterViewModel extends BaseViewModel { protected void setPasswordValidator(@Nullable Validator validator) { mPasswordValidator = validator; } @Inject RegisterViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mFirstName; final ObservableString mLastName; final ObservableString mPassword; final ObservableString mConfirmPassword; final ObservableString mLoginError; final ObservableString mFirstNameError; final ObservableString mLastNameError; final ObservableString mPasswordError; final ObservableString mConfirmPasswordError; } | @Test public void setPasswordValidator_Correct() throws Exception { Validator validator = new EmailValidator(); mModel.setPasswordValidator(validator); assertThat(mModel.mPasswordValidator, is(validator)); } |
RegisterViewModel extends BaseViewModel { public boolean isInputDataValid() { return isLoginValid() && isFirstNameValid() && isLastNameValid() && isPasswordValid() && isConfirmPasswordValid(); } @Inject RegisterViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mFirstName; final ObservableString mLastName; final ObservableString mPassword; final ObservableString mConfirmPassword; final ObservableString mLoginError; final ObservableString mFirstNameError; final ObservableString mLastNameError; final ObservableString mPasswordError; final ObservableString mConfirmPasswordError; } | @Test public void isFormValid_Correct() throws Exception { String password = "pass123"; when(mModel.mLoginValidator.isValid(any())).thenReturn(true); when(mModel.mFirstNameValidator.isValid(any())).thenReturn(true); when(mModel.mLastNameValidator.isValid(any())).thenReturn(true); when(mModel.mPasswordValidator.isValid(any())).thenReturn(true); mModel.mPassword.set(password); mModel.mConfirmPassword.set(password); assertThat(mModel.isInputDataValid(), is(true)); }
@Test public void isFormValid_ErrorLogin() throws Exception { String password = "pass123"; when(mModel.mLoginValidator.isValid(any())).thenReturn(false); when(mModel.mFirstNameValidator.isValid(any())).thenReturn(true); when(mModel.mLastNameValidator.isValid(any())).thenReturn(true); when(mModel.mPasswordValidator.isValid(any())).thenReturn(true); mModel.mPassword.set(password); mModel.mConfirmPassword.set(password); assertThat(mModel.isInputDataValid(), is(false)); }
@Test public void isFormValid_ErrorFirstName() throws Exception { String password = "pass123"; when(mModel.mLoginValidator.isValid(any())).thenReturn(true); when(mModel.mLastNameValidator.isValid(any())).thenReturn(true); when(mModel.mFirstNameValidator.isValid(any())).thenReturn(false); when(mModel.mPasswordValidator.isValid(any())).thenReturn(true); mModel.mPassword.set(password); mModel.mConfirmPassword.set(password); assertThat(mModel.isInputDataValid(), is(false)); }
@Test public void isFormValid_ErrorLastName() throws Exception { String password = "pass123"; when(mModel.mLoginValidator.isValid(any())).thenReturn(true); when(mModel.mFirstNameValidator.isValid(any())).thenReturn(true); when(mModel.mLastNameValidator.isValid(any())).thenReturn(false); when(mModel.mPasswordValidator.isValid(any())).thenReturn(true); mModel.mPassword.set(password); mModel.mConfirmPassword.set(password); assertThat(mModel.isInputDataValid(), is(false)); }
@Test public void isFormValid_ErrorPassword() throws Exception { String password = "pass123"; when(mModel.mLoginValidator.isValid(any())).thenReturn(true); when(mModel.mFirstNameValidator.isValid(any())).thenReturn(true); when(mModel.mLastNameValidator.isValid(any())).thenReturn(true); when(mModel.mPasswordValidator.isValid(any())).thenReturn(false); mModel.mPassword.set(password); mModel.mConfirmPassword.set(password); assertThat(mModel.isInputDataValid(), is(false)); }
@Test public void isFormValid_ErrorConfirmPassword() throws Exception { String password = "pass123"; when(mModel.mLoginValidator.isValid(any())).thenReturn(true); when(mModel.mFirstNameValidator.isValid(any())).thenReturn(true); when(mModel.mLastNameValidator.isValid(any())).thenReturn(true); when(mModel.mPasswordValidator.isValid(any())).thenReturn(true); mModel.mPassword.set(password); mModel.mConfirmPassword.set(password + password); assertThat(mModel.isInputDataValid(), is(false)); } |
LoginViewModel extends BaseViewModel { protected boolean isValidateLogin() { boolean valid = true; if (mLoginValidator != null && !mLoginValidator.isValid(mLogin.get())) { mLoginError.set(mViewAccess.getLoginErrorMessage()); valid = false; } else { mLoginError.set(null); } return valid; } @Inject LoginViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mLoginError; final ObservableString mPassword; final ObservableString mPasswordError; } | @Test public void validateLogin_Success() throws Exception { when(mModel.mLoginValidator.isValid(any())).thenReturn(true); assertThat(mModel.isValidateLogin(), is(true)); assertThat(Strings.isNullOrEmpty(mModel.mLoginError.get()), is(true)); }
@Test public void validateLogin_Error() throws Exception { when(mModel.mLoginValidator.isValid(any())).thenReturn(false); when(mModel.mViewAccess.getLoginErrorMessage()).thenReturn("error"); assertThat(mModel.isValidateLogin(), is(false)); assertThat(Strings.isNullOrEmpty(mModel.mLoginError.get()), is(false)); } |
LoginViewModel extends BaseViewModel { protected boolean isValidatePassword() { boolean valid = true; if (mPasswordValidator != null && !mPasswordValidator.isValid(mPassword.get())) { mPasswordError.set(mViewAccess.getPasswordErrorMessage()); valid = false; } else { mPasswordError.set(null); } return valid; } @Inject LoginViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mLoginError; final ObservableString mPassword; final ObservableString mPasswordError; } | @Test public void validatePassword_Success() throws Exception { when(mModel.mPasswordValidator.isValid(any())).thenReturn(true); assertThat(mModel.isValidatePassword(), is(true)); assertThat(Strings.isNullOrEmpty(mModel.mPasswordError.get()), is(true)); }
@Test public void validatePassword_Error() throws Exception { when(mModel.mPasswordValidator.isValid(any())).thenReturn(false); when(mModel.mViewAccess.getPasswordErrorMessage()).thenReturn("error"); assertThat(mModel.isValidatePassword(), is(false)); assertThat(Strings.isNullOrEmpty(mModel.mPasswordError.get()), is(false)); } |
LoginViewModel extends BaseViewModel { public boolean isInputDataValid() { return isValidateLogin() && isValidatePassword(); } @Inject LoginViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mLoginError; final ObservableString mPassword; final ObservableString mPasswordError; } | @Test public void isFormValid_Success() throws Exception { when(mModel.mPasswordValidator.isValid(any())).thenReturn(true); when(mModel.mLoginValidator.isValid(any())).thenReturn(true); assertThat(mModel.isInputDataValid(), is(true)); }
@Test public void isFormValid_Error() throws Exception { when(mModel.mPasswordValidator.isValid(any())).thenReturn(false); when(mModel.mLoginValidator.isValid(any())).thenReturn(true); assertThat(mModel.isInputDataValid(), is(false)); } |
LoginViewModel extends BaseViewModel { protected void setLoginValidator(@Nullable Validator loginValidator) { mLoginValidator = loginValidator; } @Inject LoginViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mLoginError; final ObservableString mPassword; final ObservableString mPasswordError; } | @Test public void setLoginValidator_Correct() throws Exception { Validator validator = new EmailValidator(); mModel.setLoginValidator(validator); assertThat(mModel.mLoginValidator, is(validator)); } |
ForgotPasswordViewModel { protected void setLoginValidator(@Nullable Validator loginValidator) { mLoginValidator = loginValidator; } @Inject ForgotPasswordViewModel(); boolean isValidateLogin(); final ObservableString mLogin; final ObservableString mLoginError; } | @Test public void setLoginValidator_Correct() throws Exception { Validator validator = new EmailValidator(); mModel.setLoginValidator(validator); assertThat(mModel.mLoginValidator, is(validator)); } |
LoginViewModel extends BaseViewModel { protected void setPasswordValidator(@Nullable Validator passwordValidator) { mPasswordValidator = passwordValidator; } @Inject LoginViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mLoginError; final ObservableString mPassword; final ObservableString mPasswordError; } | @Test public void setPasswordValidator_Correct() throws Exception { Validator validator = new EmailValidator(); mModel.setPasswordValidator(validator); assertThat(mModel.mPasswordValidator, is(validator)); } |
RegisterViewModel extends BaseViewModel { protected boolean isLoginValid() { boolean valid = true; if (mLoginValidator != null && !mLoginValidator.isValid(mLogin.get())) { mLoginError.set(mViewAccess.getLoginErrorMessage()); valid = false; } else { mLoginError.set(null); } return valid; } @Inject RegisterViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mFirstName; final ObservableString mLastName; final ObservableString mPassword; final ObservableString mConfirmPassword; final ObservableString mLoginError; final ObservableString mFirstNameError; final ObservableString mLastNameError; final ObservableString mPasswordError; final ObservableString mConfirmPasswordError; } | @Test public void validateLogin_Success() throws Exception { when(mModel.mLoginValidator.isValid(any())).thenReturn(true); assertThat(mModel.isLoginValid(), is(true)); assertThat(Strings.isNullOrEmpty(mModel.mLoginError.get()), is(true)); }
@Test public void validateLogin_Error() throws Exception { when(mModel.mLoginValidator.isValid(any())).thenReturn(false); when(mModel.mViewAccess.getLoginErrorMessage()).thenReturn("error"); assertThat(mModel.isLoginValid(), is(false)); assertThat(Strings.isNullOrEmpty(mModel.mLoginError.get()), is(false)); } |
RegisterViewModel extends BaseViewModel { protected boolean isFirstNameValid() { boolean valid = true; if (mFirstNameValidator != null && !mFirstNameValidator.isValid(mFirstName.get())) { mFirstNameError.set(mViewAccess.getFirstNameErrorMessage()); valid = false; } else { mFirstNameError.set(null); } return valid; } @Inject RegisterViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mFirstName; final ObservableString mLastName; final ObservableString mPassword; final ObservableString mConfirmPassword; final ObservableString mLoginError; final ObservableString mFirstNameError; final ObservableString mLastNameError; final ObservableString mPasswordError; final ObservableString mConfirmPasswordError; } | @Test public void validateFirstName_Success() throws Exception { when(mModel.mFirstNameValidator.isValid(any())).thenReturn(true); assertThat(mModel.isFirstNameValid(), is(true)); assertThat(Strings.isNullOrEmpty(mModel.mFirstNameError.get()), is(true)); }
@Test public void validateFirstName_Error() throws Exception { when(mModel.mFirstNameValidator.isValid(any())).thenReturn(false); when(mModel.mViewAccess.getFirstNameErrorMessage()).thenReturn("error"); assertThat(mModel.isFirstNameValid(), is(false)); assertThat(Strings.isNullOrEmpty(mModel.mFirstNameError.get()), is(false)); } |
RegisterViewModel extends BaseViewModel { protected boolean isLastNameValid() { boolean valid = true; if (mLastNameValidator != null && !mLastNameValidator.isValid(mLastName.get())) { mLastNameError.set(mViewAccess.getLastNameErrorMessage()); valid = false; } else { mLastNameError.set(null); } return valid; } @Inject RegisterViewModel(); boolean isInputDataValid(); final ObservableString mLogin; final ObservableString mFirstName; final ObservableString mLastName; final ObservableString mPassword; final ObservableString mConfirmPassword; final ObservableString mLoginError; final ObservableString mFirstNameError; final ObservableString mLastNameError; final ObservableString mPasswordError; final ObservableString mConfirmPasswordError; } | @Test public void validateLastName_Success() throws Exception { when(mModel.mLastNameValidator.isValid(any())).thenReturn(true); assertThat(mModel.isLastNameValid(), is(true)); assertThat(Strings.isNullOrEmpty(mModel.mLastNameError.get()), is(true)); }
@Test public void validateLastName_Error() throws Exception { when(mModel.mLastNameValidator.isValid(any())).thenReturn(false); when(mModel.mViewAccess.getLastNameErrorMessage()).thenReturn("error"); assertThat(mModel.isLastNameValid(), is(false)); assertThat(Strings.isNullOrEmpty(mModel.mLastNameError.get()), is(false)); } |
HK2VerticleLoader extends AbstractVerticle { @Override public void start(Future<Void> startedResult) throws Exception { realVerticle.start(startedResult); } HK2VerticleLoader(String verticleName, ClassLoader classLoader, ServiceLocator parent); @Override void init(Vertx vertx, Context context); @Override void start(Future<Void> startedResult); @Override void stop(Future<Void> stopFuture); String getVerticleName(); Verticle createRealVerticle(); static final String CONFIG_BOOTSTRAP_BINDER_NAME; static final String BOOTSTRAP_BINDER_NAME; } | @Test public void testStart_Fail() throws Exception { Verticle verticle = create(TestStartFailVerticle.class.getName()); verticle.start(startFuture); verify(startFuture, never()).complete(); verify(startFuture).fail(any(Throwable.class)); } |
HK2VerticleLoader extends AbstractVerticle { @Override public void stop(Future<Void> stopFuture) throws Exception { classLoader = null; parent = null; Future<Void> future = Future.future(); future.setHandler(result -> { ServiceLocatorFactory.getInstance().destroy(locator); locator = null; if (result.succeeded()) { stopFuture.complete(); } else { stopFuture.fail(future.cause()); } }); try { if (realVerticle != null) { realVerticle.stop(future); } else { future.complete(); } } catch (Throwable t) { future.fail(t); } } HK2VerticleLoader(String verticleName, ClassLoader classLoader, ServiceLocator parent); @Override void init(Vertx vertx, Context context); @Override void start(Future<Void> startedResult); @Override void stop(Future<Void> stopFuture); String getVerticleName(); Verticle createRealVerticle(); static final String CONFIG_BOOTSTRAP_BINDER_NAME; static final String BOOTSTRAP_BINDER_NAME; } | @Test public void testStop_Fail() throws Exception { Verticle verticle = create(TestStopFailVerticle.class.getName()); verticle.stop(stopFuture); verify(stopFuture, never()).complete(); verify(stopFuture).fail(any(Throwable.class)); }
@Test public void testStop_Throw() throws Exception { Verticle verticle = create(TestStopThrowVerticle.class.getName()); verticle.stop(stopFuture); verify(stopFuture, never()).complete(); verify(stopFuture).fail(any(Throwable.class)); } |
HK2VerticleFactory implements VerticleFactory { @Override public String prefix() { return PREFIX; } @Override String prefix(); @Override void close(); ServiceLocator getLocator(); HK2VerticleFactory setLocator(ServiceLocator locator); @Override Verticle createVerticle(String verticleName, ClassLoader classLoader); static String getIdentifier(Class<? extends Verticle> clazz); static String getIdentifier(String clazz); static final String PREFIX; } | @Test public void testPrefix() { assertEquals("java-hk2", factory.prefix()); } |
HK2VerticleFactory implements VerticleFactory { @Override public Verticle createVerticle(String verticleName, ClassLoader classLoader) throws Exception { verticleName = VerticleFactory.removePrefix(verticleName); @SuppressWarnings("unchecked") Class<Verticle> loader = (Class<Verticle>) classLoader.loadClass(HK2VerticleLoader.class.getName()); Constructor<Verticle> ctor = loader.getConstructor(String.class, ClassLoader.class, ServiceLocator.class); if (ctor == null) { throw new IllegalStateException("Could not find HK2VerticleLoad constructor"); } return ctor.newInstance(verticleName, classLoader, getLocator()); } @Override String prefix(); @Override void close(); ServiceLocator getLocator(); HK2VerticleFactory setLocator(ServiceLocator locator); @Override Verticle createVerticle(String verticleName, ClassLoader classLoader); static String getIdentifier(Class<? extends Verticle> clazz); static String getIdentifier(String clazz); static final String PREFIX; } | @Test public void testCreateVerticle() throws Exception { String identifier = HK2VerticleFactory.getIdentifier(TestHK2Verticle.class); Verticle verticle = factory.createVerticle(identifier, this.getClass().getClassLoader()); assertThat(verticle, instanceOf(HK2VerticleLoader.class)); HK2VerticleLoader loader = (HK2VerticleLoader) verticle; assertEquals(TestHK2Verticle.class.getName(), loader.getVerticleName()); } |
HK2VerticleFactory implements VerticleFactory { public HK2VerticleFactory setLocator(ServiceLocator locator) { this.locator = locator; return this; } @Override String prefix(); @Override void close(); ServiceLocator getLocator(); HK2VerticleFactory setLocator(ServiceLocator locator); @Override Verticle createVerticle(String verticleName, ClassLoader classLoader); static String getIdentifier(Class<? extends Verticle> clazz); static String getIdentifier(String clazz); static final String PREFIX; } | @Test public void testSetLocator() throws Exception { ServiceLocator original = factory.getLocator(); assertNull(original); ServiceLocator locator = mock(ServiceLocator.class); factory.setLocator(locator); assertEquals(locator, factory.getLocator()); } |
HK2VerticleFactory implements VerticleFactory { @Override public void close() { if (locator != null) { ServiceLocatorFactory.getInstance().destroy(locator); locator = null; } } @Override String prefix(); @Override void close(); ServiceLocator getLocator(); HK2VerticleFactory setLocator(ServiceLocator locator); @Override Verticle createVerticle(String verticleName, ClassLoader classLoader); static String getIdentifier(Class<? extends Verticle> clazz); static String getIdentifier(String clazz); static final String PREFIX; } | @Test public void testClose() throws Exception { ServiceLocator locator = mock(ServiceLocator.class); factory.setLocator(locator); factory.close(); verify(locator).shutdown(); } |
InternalVertxJerseyBinder extends AbstractBinder { @Override protected void configure() { bind(vertx).to(Vertx.class); bindFactory(VertxRequestReferencingFactory.class).to(HttpServerRequest.class).in(PerLookup.class); bindFactory(VertxRequestReferencingFactory.class).to(new TypeLiteral<ReadStream<HttpServerRequest>>() { }).in(PerLookup.class); bindFactory(ReferencingFactory.<HttpServerRequest>referenceFactory()).to(new TypeLiteral<Ref<HttpServerRequest>>() { }).in(RequestScoped.class); bindFactory(VertxResponseReferencingFactory.class).to(HttpServerResponse.class).in(PerLookup.class); bindFactory(ReferencingFactory.<HttpServerResponse>referenceFactory()).to(new TypeLiteral<Ref<HttpServerResponse>>() { }).in(RequestScoped.class); } InternalVertxJerseyBinder(Vertx vertx); } | @Test public void testConfigure() throws Exception { InternalVertxJerseyBinder binder = new InternalVertxJerseyBinder(mock(Vertx.class)); DynamicConfiguration dynamicConfiguration = mock(DynamicConfiguration.class); binder.bind(dynamicConfiguration); } |
DefaultJerseyOptions implements JerseyOptions, JerseyServerOptions { @Override public int getMaxBodySize() { return config.getInteger(CONFIG_MAX_BODY_SIZE, DEFAULT_MAX_BODY_SIZE); } @Inject DefaultJerseyOptions(Vertx vertx); DefaultJerseyOptions(JsonObject config); @Override List<String> getPackages(); @Override Map<String, Object> getProperties(); @Override Set<Class<?>> getComponents(); @Override Set<Object> getInstances(); String getHost(); int getPort(); boolean getSSL(); JksOptions getKeyStoreOptions(); Integer getReceiveBufferSize(); int getAcceptBacklog(); @Override URI getBaseUri(); @Override int getMaxBodySize(); boolean getCompressionSupported(); @Override HttpServerOptions getServerOptions(); final static String CONFIG_HOST; final static String CONFIG_PORT; final static String CONFIG_SSL; final static String CONFIG_JKS_OPTIONS; final static String CONFIG_RECEIVE_BUFFER_SIZE; final static String CONFIG_BACKLOG_SIZE; final static String CONFIG_RESOURCE_CONFIG; final static String CONFIG_PROPERTIES; final static String CONFIG_COMPRESSION_SUPPORTED; static final String CONFIG_BASE_PATH; static final String CONFIG_MAX_BODY_SIZE; static final String CONFIG_RESOURCES; static final String CONFIG_PACKAGES; static final String CONFIG_FEATURES; static final String CONFIG_COMPONENTS; static final String CONFIG_BINDERS; static final String CONFIG_INSTANCES; static final int DEFAULT_MAX_BODY_SIZE; } | @Test public void testGetMaxBodySize() throws Exception { int expected = DefaultJerseyOptions.DEFAULT_MAX_BODY_SIZE; int maxBodySize; maxBodySize = options.getMaxBodySize(); assertEquals(expected, maxBodySize); expected = 12; config.put(DefaultJerseyOptions.CONFIG_MAX_BODY_SIZE, expected); maxBodySize = options.getMaxBodySize(); assertEquals(expected, maxBodySize); } |
DefaultJerseyOptions implements JerseyOptions, JerseyServerOptions { @Override public List<String> getPackages() { List<String> list = new ArrayList<>(); Consumer<JsonArray> reader = array -> { if ((array != null && !array.isEmpty())) { for (int i = 0; i < array.size(); i++) { list.add(array.getString(i)); } } }; JsonArray resources = config.getJsonArray(CONFIG_RESOURCES, null); JsonArray packages = config.getJsonArray(CONFIG_PACKAGES, null); reader.accept(resources); reader.accept(packages); return list; } @Inject DefaultJerseyOptions(Vertx vertx); DefaultJerseyOptions(JsonObject config); @Override List<String> getPackages(); @Override Map<String, Object> getProperties(); @Override Set<Class<?>> getComponents(); @Override Set<Object> getInstances(); String getHost(); int getPort(); boolean getSSL(); JksOptions getKeyStoreOptions(); Integer getReceiveBufferSize(); int getAcceptBacklog(); @Override URI getBaseUri(); @Override int getMaxBodySize(); boolean getCompressionSupported(); @Override HttpServerOptions getServerOptions(); final static String CONFIG_HOST; final static String CONFIG_PORT; final static String CONFIG_SSL; final static String CONFIG_JKS_OPTIONS; final static String CONFIG_RECEIVE_BUFFER_SIZE; final static String CONFIG_BACKLOG_SIZE; final static String CONFIG_RESOURCE_CONFIG; final static String CONFIG_PROPERTIES; final static String CONFIG_COMPRESSION_SUPPORTED; static final String CONFIG_BASE_PATH; static final String CONFIG_MAX_BODY_SIZE; static final String CONFIG_RESOURCES; static final String CONFIG_PACKAGES; static final String CONFIG_FEATURES; static final String CONFIG_COMPONENTS; static final String CONFIG_BINDERS; static final String CONFIG_INSTANCES; static final int DEFAULT_MAX_BODY_SIZE; } | @Test public void testGetPackages() throws Exception { String package1 = "com.englishtown.vertx.jersey.resources1"; String package2 = "com.englishtown.vertx.jersey.resources2"; config.put(DefaultJerseyOptions.CONFIG_RESOURCES, new JsonArray().add(package1)); config.put(DefaultJerseyOptions.CONFIG_PACKAGES, new JsonArray().add(package2)); List<String> packages = options.getPackages(); assertNotNull(packages); assertEquals(2, packages.size()); assertEquals(package1, packages.get(0)); assertEquals(package2, packages.get(1)); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.