method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
CryptoUtils { static String byteArrayToHex(byte[] bytes) { return HEX_ENCODING.encode(bytes); } private CryptoUtils(); }### Answer:
@Test void byteArrayToHex() { String hex = CryptoUtils.byteArrayToHex(new byte[]{-85, -51}); assertEquals("abcd", hex); } |
### Question:
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); }### Answer:
@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(); }))); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@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(); } |
### Question:
JsonSerializer { public static Gson json() { return INSTANCE; } private JsonSerializer(); static GsonBuilder builder(); static Gson json(); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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)); } |
### Question:
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); }### Answer:
@Test void fromBytesNull() { assertThrows(NullPointerException.class, () -> serializer.fromBytes(null)); }
@Test void fromBytesInvalidInput() { byte[] invalidBuffer = new byte[32]; assertThrows(IllegalArgumentException.class, () -> serializer.fromBytes(invalidBuffer)); } |
### Question:
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); }### Answer:
@Test void fromSelf() { assertThat(CheckingSerializerDecorator.from(decorator), sameInstance(decorator)); } |
### Question:
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); }### Answer:
@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)); } |
### Question:
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); }### Answer:
@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])); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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()); } |
### Question:
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(); }### Answer:
@Test void toStringTest() { ServiceArtifactId id = ServiceArtifactId.valueOf(0, "full-name", "0.1"); assertThat(id.toString()).isEqualTo("0:full-name:0.1"); } |
### Question:
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(); }### Answer:
@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())); } |
### Question:
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); }### Answer:
@Test void checkValidSha256Hash() { HashCode hash = HashCode.fromBytes(new byte[32]); assertDoesNotThrow(() -> ProofHashes.checkSha256Hash(hash)); } |
### Question:
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(); }### Answer:
@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())); } |
### Question:
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); }### Answer:
@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]); } } |
### Question:
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(); }### Answer:
@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}); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@Test void testToString() { assertEquals("Hashing.sha256()", Hashing.sha256().toString()); assertEquals("Hashing.sha512()", Hashing.sha512().toString()); } |
### Question:
FakeServiceModule extends AbstractServiceModule { @Override protected void configure() { bind(Service.class).to(FakeService.class) .in(Singleton.class); } }### Answer:
@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)); } |
### Question:
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); }### Answer:
@Test void testShort() { TestHasher hasher = new TestHasher(); hasher.putShort((short) 0x0201); hasher.assertBytes(new byte[]{1, 2}); } |
### Question:
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); }### Answer:
@Test void testInt() { TestHasher hasher = new TestHasher(); hasher.putInt(0x04030201); hasher.assertBytes(new byte[]{1, 2, 3, 4}); } |
### Question:
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); }### Answer:
@Test void testLong() { TestHasher hasher = new TestHasher(); hasher.putLong(0x0807060504030201L); hasher.assertBytes(new byte[]{1, 2, 3, 4, 5, 6, 7, 8}); } |
### Question:
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); }### Answer:
@Test void testChar() { TestHasher hasher = new TestHasher(); hasher.putChar((char) 0x0201); hasher.assertBytes(new byte[]{1, 2}); } |
### Question:
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); }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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()); } |
### Question:
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; }### Answer:
@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()); } |
### Question:
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); }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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()); } |
### Question:
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(); }### Answer:
@Test void testFromInt() { for (ExpectedHashCode expected : expectedHashCodes) { if (expected.bytes.length == 4) { HashCode fromInt = HashCode.fromInt(expected.asInt); assertExpectedHashCode(expected, fromInt); } } } |
### Question:
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(); }### Answer:
@Test void testFromLong() { for (ExpectedHashCode expected : expectedHashCodes) { if (expected.bytes.length == 8) { HashCode fromLong = HashCode.fromLong(expected.asLong); assertExpectedHashCode(expected, fromLong); } } } |
### Question:
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(); }### Answer:
@Test void testFromBytes() { for (ExpectedHashCode expected : expectedHashCodes) { HashCode fromBytes = HashCode.fromBytes(expected.bytes); assertExpectedHashCode(expected, fromBytes); } } |
### Question:
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(); }### Answer:
@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()); } |
### Question:
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(); }### Answer:
@Test void testToString() { byte[] data = new byte[]{127, -128, 5, -1, 14}; assertEquals("7f8005ff0e", HashCode.fromBytes(data).toString()); assertEquals("7f8005ff0e", base16().lowerCase().encode(data)); } |
### Question:
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(); }### Answer:
@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")); } |
### Question:
ApiController { private void submitUnknownTx(RoutingContext rc) { HashCode txHash = service.submitUnknownTx(); replyTxSubmitted(rc, txHash); } ApiController(QaService service); }### Answer:
@Test void submitUnknown(VertxTestContext context) { when(qaService.submitUnknownTx()) .thenReturn(EXPECTED_TX_HASH); post(SUBMIT_UNKNOWN_TX_PATH) .send(checkCreatedTransaction(context, EXPECTED_TX_HASH)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@Test public void setLoginValidator_Correct() throws Exception { Validator validator = new EmailValidator(); mModel.setLoginValidator(validator); assertThat(mModel.mLoginValidator, is(validator)); } |
### Question:
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; }### Answer:
@Test public void setFirstNameValidator_Correct() throws Exception { Validator validator = new EmailValidator(); mModel.setFirstNameValidator(validator); assertThat(mModel.mFirstNameValidator, is(validator)); } |
### Question:
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; }### Answer:
@Test public void setLastNameValidator_Correct() throws Exception { Validator validator = new EmailValidator(); mModel.setLastNameValidator(validator); assertThat(mModel.mLastNameValidator, is(validator)); } |
### Question:
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; }### Answer:
@Test public void setPasswordValidator_Correct() throws Exception { Validator validator = new EmailValidator(); mModel.setPasswordValidator(validator); assertThat(mModel.mPasswordValidator, is(validator)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@Test public void setLoginValidator_Correct() throws Exception { Validator validator = new EmailValidator(); mModel.setLoginValidator(validator); assertThat(mModel.mLoginValidator, is(validator)); } |
### Question:
ForgotPasswordViewModel { protected void setLoginValidator(@Nullable Validator loginValidator) { mLoginValidator = loginValidator; } @Inject ForgotPasswordViewModel(); boolean isValidateLogin(); final ObservableString mLogin; final ObservableString mLoginError; }### Answer:
@Test public void setLoginValidator_Correct() throws Exception { Validator validator = new EmailValidator(); mModel.setLoginValidator(validator); assertThat(mModel.mLoginValidator, is(validator)); } |
### Question:
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; }### Answer:
@Test public void setPasswordValidator_Correct() throws Exception { Validator validator = new EmailValidator(); mModel.setPasswordValidator(validator); assertThat(mModel.mPasswordValidator, is(validator)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@Test public void testPrefix() { assertEquals("java-hk2", factory.prefix()); } |
### Question:
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; }### Answer:
@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()); } |
### Question:
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; }### Answer:
@Test public void testSetLocator() throws Exception { ServiceLocator original = factory.getLocator(); assertNull(original); ServiceLocator locator = mock(ServiceLocator.class); factory.setLocator(locator); assertEquals(locator, factory.getLocator()); } |
### Question:
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; }### Answer:
@Test public void testClose() throws Exception { ServiceLocator locator = mock(ServiceLocator.class); factory.setLocator(locator); factory.close(); verify(locator).shutdown(); } |
### Question:
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); }### Answer:
@Test public void testConfigure() throws Exception { InternalVertxJerseyBinder binder = new InternalVertxJerseyBinder(mock(Vertx.class)); DynamicConfiguration dynamicConfiguration = mock(DynamicConfiguration.class); binder.bind(dynamicConfiguration); } |
### Question:
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; }### Answer:
@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); } |
### Question:
VertxResponseWriterProvider implements ContainerResponseWriterProvider { @Override public ContainerResponseWriter get( HttpServerRequest vertxRequest, ContainerRequest jerseyRequest) { return new VertxResponseWriter(vertxRequest, vertx, responseProcessors, postResponseProcessors); } @Inject VertxResponseWriterProvider(
Vertx vertx,
List<VertxResponseProcessor> responseProcessors,
List<VertxPostResponseProcessor> postResponseProcessors); @Override ContainerResponseWriter get(
HttpServerRequest vertxRequest,
ContainerRequest jerseyRequest); }### Answer:
@Test public void testGet() throws Exception { ContainerResponseWriter writer; writer = provider.get(vertxRequest, jerseyRequest); assertNotNull(writer); } |
### Question:
DefaultJerseyServer implements JerseyServer { @Override public JerseyHandler getHandler() { return jerseyHandler; } @Inject DefaultJerseyServer(JerseyHandler jerseyHandler, VertxContainer container, Provider<JerseyServerOptions> optionsProvider); @Override void start(@Nullable JerseyServerOptions options, @Nullable JerseyOptions jerseyOptions, @Nullable Handler<AsyncResult<HttpServer>> doneHandler); @Override void setupHandler(Handler<HttpServer> handler); @Override JerseyHandler getHandler(); @Override HttpServer getHttpServer(); @Override void stop(); }### Answer:
@Test public void testGetHandler() throws Exception { jerseyServer.start(); JerseyHandler handler = jerseyServer.getHandler(); assertEquals(jerseyHandler, handler); } |
### Question:
DefaultJerseyServer implements JerseyServer { @Override public void setupHandler(Handler<HttpServer> handler) { this.setupHandler = handler; } @Inject DefaultJerseyServer(JerseyHandler jerseyHandler, VertxContainer container, Provider<JerseyServerOptions> optionsProvider); @Override void start(@Nullable JerseyServerOptions options, @Nullable JerseyOptions jerseyOptions, @Nullable Handler<AsyncResult<HttpServer>> doneHandler); @Override void setupHandler(Handler<HttpServer> handler); @Override JerseyHandler getHandler(); @Override HttpServer getHttpServer(); @Override void stop(); }### Answer:
@Test public void testSetupHandler() throws Exception { jerseyServer.setupHandler(setupHandler); jerseyServer.start(); verify(setupHandler).handle(eq(httpServer)); Handler<HttpServerRequest> requestHandler = jerseyServer.getHandler(); assertNotNull(requestHandler); httpServer.requestHandler(request -> { }); } |
### Question:
DefaultJerseyServer implements JerseyServer { @Override public HttpServer getHttpServer() { return server; } @Inject DefaultJerseyServer(JerseyHandler jerseyHandler, VertxContainer container, Provider<JerseyServerOptions> optionsProvider); @Override void start(@Nullable JerseyServerOptions options, @Nullable JerseyOptions jerseyOptions, @Nullable Handler<AsyncResult<HttpServer>> doneHandler); @Override void setupHandler(Handler<HttpServer> handler); @Override JerseyHandler getHandler(); @Override HttpServer getHttpServer(); @Override void stop(); }### Answer:
@Test public void testGetHttpServer() throws Exception { jerseyServer.start(); HttpServer server = jerseyServer.getHttpServer(); assertEquals(httpServer, server); } |
### Question:
DefaultWhenJerseyServer implements WhenJerseyServer { @Override public Promise<JerseyServer> createServer(@Nullable JerseyServerOptions options, @Nullable JerseyOptions jerseyOptions) { final Deferred<JerseyServer> d = when.defer(); try { JerseyServer jerseyServer = jerseyServerProvider.get(); jerseyServer.start(options, jerseyOptions, result -> { if (result.succeeded()) { d.resolve(jerseyServer); } else { d.reject(result.cause()); } }); } catch (RuntimeException e) { d.reject(e); } return d.getPromise(); } @Inject DefaultWhenJerseyServer(Vertx vertx, Provider<JerseyServer> jerseyServerProvider, When when); @Override Promise<JerseyServer> createServer(@Nullable JerseyServerOptions options, @Nullable JerseyOptions jerseyOptions); @Override Promise<String> createServerSimple(); }### Answer:
@Test public void testCreateServer_Success() throws Exception { when(result.succeeded()).thenReturn(true); whenJerseyServer.createServer() .then(done.onFulfilled, done.onRejected); verify(server).start(any(), any(), handlerCaptor.capture()); handlerCaptor.getValue().handle(result); done.assertFulfilled(); }
@Test public void testCreateServer_Fail() throws Exception { when(result.succeeded()).thenReturn(false); whenJerseyServer.createServer() .then(done.onFulfilled, done.onRejected); verify(server).start(any(), any(), handlerCaptor.capture()); handlerCaptor.getValue().handle(result); done.assertRejected(); } |
### Question:
DefaultJerseyHandler implements JerseyHandler { @Override public URI getBaseUri() { if (baseUri == null) { baseUri = getContainer().getOptions().getBaseUri(); if (baseUri == null) { throw new IllegalStateException("baseUri is null, have you called init() first?"); } } return baseUri; } @Inject DefaultJerseyHandler(
Provider<VertxContainer> containerProvider,
ContainerResponseWriterProvider responseWriterProvider,
List<VertxRequestProcessor> requestProcessors); @Override URI getBaseUri(); int getMaxBodySize(); @Override ApplicationHandlerDelegate getDelegate(); @Override VertxContainer getContainer(); @Override JerseyHandler setContainer(VertxContainer container); @Override void handle(final HttpServerRequest vertxRequest); }### Answer:
@Test public void testGetBaseURI() throws Exception { URI baseUri = URI.create("/test"); when(options.getBaseUri()).thenReturn(baseUri); URI result = jerseyHandler.getBaseUri(); assertEquals(baseUri, result); } |
### Question:
VertxResponseWriter implements ContainerResponseWriter { @Override public boolean suspend(long timeOut, TimeUnit timeUnit, TimeoutHandler timeoutHandler) { this.timeoutHandler = timeoutHandler; if (suspendTimerId != 0) { vertx.cancelTimer(suspendTimerId); suspendTimerId = 0; } if (timeOut <= 0) { return true; } long ms = timeUnit.toMillis(timeOut); this.suspendTimerId = vertx.setTimer(ms, id -> { if (id == suspendTimerId) { VertxResponseWriter.this.timeoutHandler.onTimeout(VertxResponseWriter.this); } }); return true; } @Inject VertxResponseWriter(
HttpServerRequest vertxRequest,
Vertx vertx,
List<VertxResponseProcessor> responseProcessors,
List<VertxPostResponseProcessor> postResponseProcessors); @Override OutputStream writeResponseStatusAndHeaders(long contentLength, ContainerResponse responseContext); @Override boolean suspend(long timeOut, TimeUnit timeUnit, TimeoutHandler timeoutHandler); @Override void setSuspendTimeout(long timeOut, TimeUnit timeUnit); @Override void commit(); @Override void failure(Throwable error); @Override boolean enableResponseBuffering(); }### Answer:
@Test public void testSuspend() throws Exception { boolean result; ContainerResponseWriter.TimeoutHandler timeoutHandler = mock(ContainerResponseWriter.TimeoutHandler.class); result = writer.suspend(10, TimeUnit.SECONDS, timeoutHandler); assertTrue(result); verify(vertx, times(1)).setTimer(anyLong(), any(Handler.class)); result = writer.suspend(0, TimeUnit.SECONDS, timeoutHandler); assertTrue(result); verify(vertx, times(1)).setTimer(anyLong(), any(Handler.class)); result = writer.suspend(10, TimeUnit.SECONDS, timeoutHandler); assertTrue(result); verify(vertx, times(2)).setTimer(anyLong(), any(Handler.class)); } |
### Question:
VertxResponseWriter implements ContainerResponseWriter { @Override public void setSuspendTimeout(long timeOut, TimeUnit timeUnit) throws IllegalStateException { if (timeoutHandler == null) { throw new IllegalStateException("The timeoutHandler is null"); } suspend(timeOut, timeUnit, timeoutHandler); } @Inject VertxResponseWriter(
HttpServerRequest vertxRequest,
Vertx vertx,
List<VertxResponseProcessor> responseProcessors,
List<VertxPostResponseProcessor> postResponseProcessors); @Override OutputStream writeResponseStatusAndHeaders(long contentLength, ContainerResponse responseContext); @Override boolean suspend(long timeOut, TimeUnit timeUnit, TimeoutHandler timeoutHandler); @Override void setSuspendTimeout(long timeOut, TimeUnit timeUnit); @Override void commit(); @Override void failure(Throwable error); @Override boolean enableResponseBuffering(); }### Answer:
@Test public void testSetSuspendTimeout() throws Exception { ContainerResponseWriter.TimeoutHandler timeoutHandler = mock(ContainerResponseWriter.TimeoutHandler.class); try { writer.setSuspendTimeout(10, TimeUnit.SECONDS); fail(); } catch (IllegalStateException e) { } writer.suspend(0, TimeUnit.SECONDS, timeoutHandler); writer.setSuspendTimeout(5, TimeUnit.MINUTES); verify(vertx, times(1)).setTimer(anyLong(), any(Handler.class)); } |
### Question:
VertxResponseWriter implements ContainerResponseWriter { @Override public void commit() { if (!isWriteStream) { end(); } } @Inject VertxResponseWriter(
HttpServerRequest vertxRequest,
Vertx vertx,
List<VertxResponseProcessor> responseProcessors,
List<VertxPostResponseProcessor> postResponseProcessors); @Override OutputStream writeResponseStatusAndHeaders(long contentLength, ContainerResponse responseContext); @Override boolean suspend(long timeOut, TimeUnit timeUnit, TimeoutHandler timeoutHandler); @Override void setSuspendTimeout(long timeOut, TimeUnit timeUnit); @Override void commit(); @Override void failure(Throwable error); @Override boolean enableResponseBuffering(); }### Answer:
@Test public void testCommit() throws Exception { VertxPostResponseProcessor processor1 = mock(VertxPostResponseProcessor.class); VertxPostResponseProcessor processor2 = mock(VertxPostResponseProcessor.class); postResponseProcessors.add(processor1); postResponseProcessors.add(processor2); writer.commit(); verify(response).end(); verify(processor1).process(eq(response), any(ContainerResponse.class)); verify(processor2).process(eq(response), any(ContainerResponse.class)); } |
### Question:
VertxResponseWriter implements ContainerResponseWriter { @Override public void failure(Throwable error) { logger.error(error.getMessage(), error); HttpServerResponse response = vertxRequest.response(); Response.Status status = Response.Status.INTERNAL_SERVER_ERROR; response.setStatusCode(status.getStatusCode()); response.setStatusMessage(status.getReasonPhrase()); response.end(); } @Inject VertxResponseWriter(
HttpServerRequest vertxRequest,
Vertx vertx,
List<VertxResponseProcessor> responseProcessors,
List<VertxPostResponseProcessor> postResponseProcessors); @Override OutputStream writeResponseStatusAndHeaders(long contentLength, ContainerResponse responseContext); @Override boolean suspend(long timeOut, TimeUnit timeUnit, TimeoutHandler timeoutHandler); @Override void setSuspendTimeout(long timeOut, TimeUnit timeUnit); @Override void commit(); @Override void failure(Throwable error); @Override boolean enableResponseBuffering(); }### Answer:
@Test public void testFailure() throws Exception { Throwable error = mock(Throwable.class); writer.failure(error); verify(response, times(1)).setStatusCode(eq(500)); verify(response, times(1)).setStatusMessage(eq("Internal Server Error")); verify(response, times(1)).end(); } |
### Question:
VertxResponseWriter implements ContainerResponseWriter { @Override public boolean enableResponseBuffering() { return false; } @Inject VertxResponseWriter(
HttpServerRequest vertxRequest,
Vertx vertx,
List<VertxResponseProcessor> responseProcessors,
List<VertxPostResponseProcessor> postResponseProcessors); @Override OutputStream writeResponseStatusAndHeaders(long contentLength, ContainerResponse responseContext); @Override boolean suspend(long timeOut, TimeUnit timeUnit, TimeoutHandler timeoutHandler); @Override void setSuspendTimeout(long timeOut, TimeUnit timeUnit); @Override void commit(); @Override void failure(Throwable error); @Override boolean enableResponseBuffering(); }### Answer:
@Test public void testEnableResponseBuffering() throws Exception { boolean result; result = writer.enableResponseBuffering(); assertFalse(result); } |
### Question:
GuiceJerseyBinder extends AbstractModule { @Override protected void configure() { ServiceLocator locator = ServiceLocatorFactory.getInstance().create(null); bind(ServiceLocator.class).toInstance(locator); bind(VertxContainer.class).to(DefaultVertxContainer.class); bind(JerseyServer.class).to(GuiceJerseyServer.class); bind(JerseyHandler.class).to(DefaultJerseyHandler.class); bind(JerseyOptions.class).to(DefaultJerseyOptions.class); bind(JerseyServerOptions.class).to(DefaultJerseyOptions.class); bind(ContainerResponseWriterProvider.class).to(VertxResponseWriterProvider.class); bind(MessageBodyWriter.class).to(WriteStreamBodyWriter.class).in(Singleton.class); bind(ApplicationConfigurator.class).toProvider(Providers.of(null)); Multibinder.newSetBinder(binder(), VertxRequestProcessor.class); Multibinder.newSetBinder(binder(), VertxResponseProcessor.class); Multibinder.newSetBinder(binder(), VertxPostResponseProcessor.class); Multibinder.newSetBinder(binder(), ContainerRequestFilter.class); Multibinder.newSetBinder(binder(), ContainerResponseFilter.class); Multibinder.newSetBinder(binder(), ReaderInterceptor.class); Multibinder.newSetBinder(binder(), WriterInterceptor.class); Multibinder.newSetBinder(binder(), ModelProcessor.class); Multibinder.newSetBinder(binder(), ContainerLifecycleListener.class); Multibinder.newSetBinder(binder(), ApplicationEventListener.class); Multibinder.newSetBinder(binder(), ExceptionMapper.class); } }### Answer:
@Test public void testConfigure() throws Exception { binder.configure(builder); verify(builder, times(9)).bind((Class<?>) any(Class.class)); verify(builder, times(11)).install(any(Module.class)); } |
### Question:
BootstrapBinder extends AbstractModule { @Override protected void configure() { install(new GuiceJerseyBinder()); } }### Answer:
@Test public void testConfigure() throws Exception { binder.configure(builder); verify(builder).install(any(GuiceJerseyBinder.class)); } |
### Question:
BootstrapBinder extends AbstractBinder { @Override protected void configure() { install(new HK2JerseyBinder()); } }### Answer:
@Test public void testConfigure() throws Exception { BootstrapBinder binder = new BootstrapBinder(); DynamicConfiguration dynamicConfiguration = mock(DynamicConfiguration.class); binder.bind(dynamicConfiguration); } |
### Question:
SwaggerServletConfig implements ServletConfig { @Override public String getInitParameter(String name) { return initParams.get(name); } @Inject SwaggerServletConfig(ServletContext context, Configuration config); @Override String getServletName(); @Override ServletContext getServletContext(); @Override String getInitParameter(String name); @Override Enumeration<String> getInitParameterNames(); static final String PROPERTY_PREFIX; }### Answer:
@Test public void testInitParamsCreation() throws Exception { servletConfig = new SwaggerServletConfig(context, configuration); assertNotNull(servletConfig); assertEquals(configId, servletConfig.getInitParameter(CONFIG_ID_KEY)); assertEquals(scannerId, servletConfig.getInitParameter(SCANNER_ID_KEY)); assertEquals(contextId, servletConfig.getInitParameter(CONTEXT_ID_KEY)); }
@Test public void testInitParamsCreation_nullProperty() throws Exception { properties.put(CONFIG_ID_KEY, null); servletConfig = new SwaggerServletConfig(context, configuration); assertNotNull(servletConfig); assertNull(servletConfig.getInitParameter(CONFIG_ID_KEY)); }
@Test public void testInitParamsCreation_ignoredProperty() throws Exception { String ignoredKey = "ignore"; properties.put(ignoredKey, "test-value"); servletConfig = new SwaggerServletConfig(context, configuration); assertNotNull(servletConfig); assertNull(servletConfig.getInitParameter(ignoredKey)); } |
### Question:
SwaggerServletConfig implements ServletConfig { @Override public Enumeration<String> getInitParameterNames() { return Collections.enumeration(initParams.keySet()); } @Inject SwaggerServletConfig(ServletContext context, Configuration config); @Override String getServletName(); @Override ServletContext getServletContext(); @Override String getInitParameter(String name); @Override Enumeration<String> getInitParameterNames(); static final String PROPERTY_PREFIX; }### Answer:
@Test public void testGetInitParameterNames() throws Exception { servletConfig = new SwaggerServletConfig(context, configuration); Enumeration<String> paramNames = servletConfig.getInitParameterNames(); assertNotNull(paramNames); while (paramNames.hasMoreElements()) { assertTrue(properties.keySet().contains(paramNames.nextElement())); } } |
### Question:
JerseyVerticle extends AbstractVerticle { @Override public void start(final Future<Void> startedResult) throws Exception { this.start(); jerseyServer.start(ar -> { if (ar.succeeded()) { startedResult.complete(); } else { startedResult.fail(ar.cause()); } }); } @Inject JerseyVerticle(JerseyServer jerseyServer, JerseyOptions options); @Override void start(final Future<Void> startedResult); @Override void stop(); }### Answer:
@Test public void testStart() throws Exception { jerseyVerticle.start(startedResult); verify(startedResult, never()).complete(); verify(startedResult, never()).fail(any(Throwable.class)); verify(jerseyServer).start(handlerCaptor.capture()); when(asyncResult.succeeded()).thenReturn(true).thenReturn(false); handlerCaptor.getValue().handle(asyncResult); verify(startedResult).complete(); verify(startedResult, never()).fail(any(Throwable.class)); handlerCaptor.getValue().handle(asyncResult); verify(startedResult).complete(); verify(startedResult).fail(any(Throwable.class)); } |
### Question:
SwaggerFeature implements Feature { @Override public boolean configure(FeatureContext context) { Configuration config = context.getConfiguration(); if (PropertiesHelper.isProperty(config.getProperties(), PROPERTY_DISABLE)) { return false; } if (!PropertiesHelper.isProperty(config.getProperties(), PROPERTY_CORS_DISABLE)) { context.register(SwaggerCorsFilter.class); } if (!config.isRegistered(ApiListingResource.class)) { context.register(ApiListingResource.class); context.register(SwaggerSerializers.class); } if (ScannerFactory.getScanner() == null) { ScannerFactory.setScanner(new DefaultJaxrsScanner()); } if (!config.isRegistered(ServletContext.class)) { context.register(new SwaggerFeatureBinder()); } return true; } @Override boolean configure(FeatureContext context); static final String PROPERTY_DISABLE; static final String PROPERTY_CORS_DISABLE; }### Answer:
@Test public void testConfigure() throws Exception { boolean result = feature.configure(context); assertTrue(result); verify(context).register(eq(SwaggerCorsFilter.class)); verify(context).register(eq(ApiListingResource.class)); verify(context).register(eq(SwaggerSerializers.class)); }
@Test public void testConfigure_Disable() throws Exception { properties.put(SwaggerFeature.PROPERTY_DISABLE, true); boolean result = feature.configure(context); assertFalse(result); verify(context, never()).register(any()); } |
### Question:
JacksonFeature implements Feature { @Override public boolean configure(FeatureContext context) { Configuration config = context.getConfiguration(); boolean disabled = PropertiesHelper.isProperty(config.getProperties(), PROPERTY_DISABLE); if (disabled) { return false; } if (!config.isRegistered(ObjectMapperConfigurator.class)) { context.register(new Binder()); context.register(ObjectMapperProvider.class); } return true; } @Override boolean configure(FeatureContext context); static final String PROPERTY_DISABLE; }### Answer:
@Test public void testConfigure() throws Exception { boolean result; result = feature.configure(context); assertTrue(result); verify(context).register(Matchers.<JacksonFeature.Binder>any()); verify(context).register(eq(ObjectMapperProvider.class)); }
@Test public void testConfigure_Disable() throws Exception { properties.put(JacksonFeature.PROPERTY_DISABLE, true); boolean result; result = feature.configure(context); assertFalse(result); verify(context, never()).register(Matchers.<JacksonFeature.Binder>any()); verify(context, never()).register(eq(ObjectMapperProvider.class)); } |
### Question:
DefaultVertxContainer implements VertxContainer { @Override public void start() { if (started) { return; } ApplicationHandler handler = getApplicationHandler(); if (handler == null) { throw new IllegalStateException("ApplicationHandler cannot be null"); } handler.onStartup(this); started = true; } @Inject DefaultVertxContainer(Vertx vertx, JerseyOptions options, @Optional @Nullable ServiceLocator locator, @Optional @Nullable ApplicationConfigurator configurator); @Override void start(); @Override void stop(); @Override Vertx getVertx(); @Override JerseyOptions getOptions(); @Override VertxContainer setOptions(JerseyOptions options); @Override ApplicationHandlerDelegate getApplicationHandlerDelegate(); @Override ResourceConfig getConfiguration(); @Override ApplicationHandler getApplicationHandler(); @Override void reload(); @Override void reload(ResourceConfig configuration); }### Answer:
@Test public void testStart() throws Exception { packages.add("com.englishtown.vertx.jersey.resources"); container = new DefaultVertxContainer(vertx, options, locator, null); container.start(); assertEquals(options, container.getOptions()); assertNotNull(container.getConfiguration()); assertNotNull(container.getApplicationHandler()); assertNotNull(container.getApplicationHandlerDelegate()); }
@Test public void testResourceConfigModifier() throws Exception { boolean[] b = {false}; ApplicationConfigurator configurator = rc -> { b[0] = true; return rc; }; packages.add("com.englishtown.vertx.jersey.resources"); container = new DefaultVertxContainer(vertx, options, locator, configurator); container.start(); assertTrue(b[0]); }
@Test public void testInit_Missing_Resources() throws Exception { try { container = new DefaultVertxContainer(vertx, options, locator, null); container.start(); fail(); } catch (IllegalStateException e) { assertEquals("At least one resource package name or component must be specified", e.getMessage()); } } |
### Question:
DefaultVertxContainer implements VertxContainer { @Override public void stop() { if (!started) { return; } getApplicationHandler().onShutdown(this); applicationHandlerDelegate = null; started = false; } @Inject DefaultVertxContainer(Vertx vertx, JerseyOptions options, @Optional @Nullable ServiceLocator locator, @Optional @Nullable ApplicationConfigurator configurator); @Override void start(); @Override void stop(); @Override Vertx getVertx(); @Override JerseyOptions getOptions(); @Override VertxContainer setOptions(JerseyOptions options); @Override ApplicationHandlerDelegate getApplicationHandlerDelegate(); @Override ResourceConfig getConfiguration(); @Override ApplicationHandler getApplicationHandler(); @Override void reload(); @Override void reload(ResourceConfig configuration); }### Answer:
@Test public void testStop() throws Exception { packages.add("com.englishtown.vertx.jersey.resources"); container = new DefaultVertxContainer(vertx, options, locator, null); container.start(); container.stop(); } |
### Question:
DefaultJerseyOptions implements JerseyOptions, JerseyServerOptions { @Override public URI getBaseUri() { String basePath = config.getString(CONFIG_BASE_PATH, "/"); if (!basePath.endsWith("/")) { basePath += "/"; } return URI.create(basePath); } @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; }### Answer:
@Test public void testGetBaseUri() throws Exception { URI uri; String expected = "/"; uri = options.getBaseUri(); assertEquals(expected, uri.getPath()); expected = "test/base/path"; config.put(DefaultJerseyOptions.CONFIG_BASE_PATH, expected); expected += "/"; uri = options.getBaseUri(); assertEquals(expected, uri.getPath()); } |
### Question:
StringUtils { public static boolean isEmpty(CharSequence s) { return s == null || s.length() == 0; } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testIsEmpty() throws Exception { assertThat(isEmpty("")).isTrue(); assertThat(isEmpty(null)).isTrue(); assertThat(isEmpty(" ")).isFalse(); } |
### Question:
StringUtils { public static String toSBC(String s) { if (isEmpty(s)) return s; char[] chars = s.toCharArray(); for (int i = 0, len = chars.length; i < len; i++) { if (chars[i] == ' ') { chars[i] = (char) 12288; } else if (33 <= chars[i] && chars[i] <= 126) { chars[i] = (char) (chars[i] + 65248); } else { chars[i] = chars[i]; } } return new String(chars); } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testToSBC() throws Exception { assertThat(toSBC(" ,.&")).isEqualTo(" ，．＆"); } |
### Question:
StringUtils { public static boolean isSpace(String s) { if (s == null) return true; for (int i = 0, len = s.length(); i < len; ++i) { if (!Character.isWhitespace(s.charAt(i))) { return false; } } return true; } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testIsSpace() throws Exception { assertThat(isSpace("")).isTrue(); assertThat(isSpace(null)).isTrue(); assertThat(isSpace(" ")).isTrue(); assertThat(isSpace(" \n\t\r")).isTrue(); } |
### Question:
StringUtils { public static boolean equals(CharSequence a, CharSequence b) { if (a == b) return true; int length; if (a != null && b != null && (length = a.length()) == b.length()) { if (a instanceof String && b instanceof String) { return a.equals(b); } else { for (int i = 0; i < length; i++) { if (a.charAt(i) != b.charAt(i)) return false; } return true; } } return false; } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testEquals() throws Exception { assertThat(StringUtils.equals("blankj", "blankj")).isEqualTo(true); assertThat(StringUtils.equals("blankj", "Blankj")).isEqualTo(false); } |
### Question:
StringUtils { public static boolean equalsIgnoreCase(String a, String b) { return a == null ? b == null : a.equalsIgnoreCase(b); } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testEqualsIgnoreCase() throws Exception { assertThat(equalsIgnoreCase(null, null)).isEqualTo(true); assertThat(equalsIgnoreCase(null, "blankj")).isEqualTo(false); assertThat(equalsIgnoreCase("blankj", "Blankj")).isEqualTo(true); assertThat(equalsIgnoreCase("blankj", "blankj")).isEqualTo(true); assertThat(equalsIgnoreCase("blankj", "blank")).isEqualTo(false); } |
### Question:
EncodeUtils { public static String urlEncode(String input) { return urlEncode(input, "UTF-8"); } private EncodeUtils(); static String urlEncode(String input); static String urlEncode(String input, String charset); static String urlDecode(String input); static String urlDecode(String input, String charset); static byte[] base64Encode(String input); static byte[] base64Encode(byte[] input); static String base64Encode2String(byte[] input); static byte[] base64Decode(String input); static byte[] base64Decode(byte[] input); static byte[] base64UrlSafeEncode(String input); static String htmlEncode(CharSequence input); @SuppressWarnings("deprecation") static CharSequence htmlDecode(String input); }### Answer:
@Test public void testUrlEncode() throws Exception { assertThat(urlEncode("哈哈哈")).isEqualTo(urlEncodeString); assertThat(urlEncode("哈哈哈", "UTF-8")).isEqualTo(urlEncodeString); } |
### Question:
StringUtils { public static String null2Length0(String s) { return s == null ? "" : s; } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testNull2Length0() throws Exception { assertThat(null2Length0(null)).isEqualTo(""); } |
### Question:
EncodeUtils { public static String urlDecode(String input) { return urlDecode(input, "UTF-8"); } private EncodeUtils(); static String urlEncode(String input); static String urlEncode(String input, String charset); static String urlDecode(String input); static String urlDecode(String input, String charset); static byte[] base64Encode(String input); static byte[] base64Encode(byte[] input); static String base64Encode2String(byte[] input); static byte[] base64Decode(String input); static byte[] base64Decode(byte[] input); static byte[] base64UrlSafeEncode(String input); static String htmlEncode(CharSequence input); @SuppressWarnings("deprecation") static CharSequence htmlDecode(String input); }### Answer:
@Test public void testUrlDecode() throws Exception { assertThat(urlDecode(urlEncodeString)).isEqualTo("哈哈哈"); assertThat(urlDecode(urlEncodeString, "UTF-8")).isEqualTo("哈哈哈"); } |
### Question:
EncodeUtils { @SuppressWarnings("deprecation") public static CharSequence htmlDecode(String input) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) { return Html.fromHtml(input, Html.FROM_HTML_MODE_LEGACY); } else { return Html.fromHtml(input); } } private EncodeUtils(); static String urlEncode(String input); static String urlEncode(String input, String charset); static String urlDecode(String input); static String urlDecode(String input, String charset); static byte[] base64Encode(String input); static byte[] base64Encode(byte[] input); static String base64Encode2String(byte[] input); static byte[] base64Decode(String input); static byte[] base64Decode(byte[] input); static byte[] base64UrlSafeEncode(String input); static String htmlEncode(CharSequence input); @SuppressWarnings("deprecation") static CharSequence htmlDecode(String input); }### Answer:
@Test public void testHtmlDecode() throws Exception { assertThat(htmlDecode(encodeHtml).toString()).isEqualTo(html); } |
### Question:
PinyinUtils { public static String getPinyinFirstLetter(CharSequence ccs) { if (ccs == null || ccs.length() == 0) return null; return ccs2Pinyin(String.valueOf(ccs.charAt(0))).substring(0, 1); } private PinyinUtils(); static String ccs2Pinyin(CharSequence ccs); static String ccs2Pinyin(CharSequence ccs, CharSequence split); static String getPinyinFirstLetter(CharSequence ccs); static String getPinyinFirstLetters(CharSequence ccs); static String getPinyinFirstLetters(CharSequence ccs, CharSequence split); static String getSurnamePinyin(CharSequence name); static String getSurnameFirstLetter(CharSequence name); }### Answer:
@Test public void getPinyinFirstLetter() throws Exception { System.out.println("单: " + PinyinUtils.getPinyinFirstLetter("单")); System.out.println("元: " + PinyinUtils.getPinyinFirstLetter("元")); System.out.println("測: " + PinyinUtils.getPinyinFirstLetter("測")); System.out.println("試: " + PinyinUtils.getPinyinFirstLetter("試")); } |
### Question:
PinyinUtils { public static String getPinyinFirstLetters(CharSequence ccs) { return getPinyinFirstLetters(ccs, ""); } private PinyinUtils(); static String ccs2Pinyin(CharSequence ccs); static String ccs2Pinyin(CharSequence ccs, CharSequence split); static String getPinyinFirstLetter(CharSequence ccs); static String getPinyinFirstLetters(CharSequence ccs); static String getPinyinFirstLetters(CharSequence ccs, CharSequence split); static String getSurnamePinyin(CharSequence name); static String getSurnameFirstLetter(CharSequence name); }### Answer:
@Test public void getPinyinFirstLetters() throws Exception { System.out.println("單元測試: " + PinyinUtils.getPinyinFirstLetters("單元測試", ",")); } |
### Question:
PinyinUtils { public static String ccs2Pinyin(CharSequence ccs) { return ccs2Pinyin(ccs, ""); } private PinyinUtils(); static String ccs2Pinyin(CharSequence ccs); static String ccs2Pinyin(CharSequence ccs, CharSequence split); static String getPinyinFirstLetter(CharSequence ccs); static String getPinyinFirstLetters(CharSequence ccs); static String getPinyinFirstLetters(CharSequence ccs, CharSequence split); static String getSurnamePinyin(CharSequence name); static String getSurnameFirstLetter(CharSequence name); }### Answer:
@Test public void ccs2Pinyin() throws Exception { long t = System.currentTimeMillis(); System.out.println("已初始化的汉字转拼音用时测试: " + PinyinUtils.ccs2Pinyin("已初始化的汉字转拼音用时测试", " ")); System.out.printf("用时: %dms\n", System.currentTimeMillis() - t); } |
### Question:
RegexUtils { public static boolean isMobileSimple(CharSequence input) { return isMatch(RegexConstants.REGEX_MOBILE_SIMPLE, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testIsMobileSimple() throws Exception { assertThat(isMobileSimple("11111111111")).isTrue(); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.