Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: Block extends Message { public Date getTime() { return new Date(getTimeSeconds()*1000); } Block(NetworkParameters params); Block(NetworkParameters params, byte[] payloadBytes); Block(NetworkParameters params, byte[] payloadBytes, boolean parseLazy, boolean parseRetain, int length); BigInteger getBlockInflation(int height); int getOptimalEncodingMessageSize(); void ensureParsed(); void ensureParsedHeader(); void ensureParsedTransactions(); byte[] litecoinSerialize(); String getHashAsString(); String getScryptHashAsString(); Sha256Hash getHash(); Sha256Hash getScryptHash(); BigInteger getWork(); Block cloneAsHeader(); @Override String toString(); BigInteger getDifficultyTargetAsInteger(); void verifyHeader(); void verifyTransactions(); void verify(); @Override boolean equals(Object o); @Override int hashCode(); Sha256Hash getMerkleRoot(); void addTransaction(Transaction t); long getVersion(); Sha256Hash getPrevBlockHash(); long getTimeSeconds(); Date getTime(); long getDifficultyTarget(); long getNonce(); List<Transaction> getTransactions(); Block createNextBlock(Address to, TransactionOutPoint prevOut); Block createNextBlock(Address to, BigInteger value); Block createNextBlock(Address to); Block createNextBlockWithCoinbase(byte[] pubKey, BigInteger coinbaseValue); static final int HEADER_SIZE; static final int MAX_BLOCK_SIZE; static final int MAX_BLOCK_SIGOPS; }### Answer: @SuppressWarnings("deprecation") @Test public void testDate() throws Exception { Block block = new Block(params, blockBytes); assertEquals("4 Nov 2010 16:06:04 GMT", block.getTime().toGMTString()); }
### Question: Block extends Message { public void verify() throws VerificationException { verifyHeader(); verifyTransactions(); } Block(NetworkParameters params); Block(NetworkParameters params, byte[] payloadBytes); Block(NetworkParameters params, byte[] payloadBytes, boolean parseLazy, boolean parseRetain, int length); BigInteger getBlockInflation(int height); int getOptimalEncodingMessageSize(); void ensureParsed(); void ensureParsedHeader(); void ensureParsedTransactions(); byte[] litecoinSerialize(); String getHashAsString(); String getScryptHashAsString(); Sha256Hash getHash(); Sha256Hash getScryptHash(); BigInteger getWork(); Block cloneAsHeader(); @Override String toString(); BigInteger getDifficultyTargetAsInteger(); void verifyHeader(); void verifyTransactions(); void verify(); @Override boolean equals(Object o); @Override int hashCode(); Sha256Hash getMerkleRoot(); void addTransaction(Transaction t); long getVersion(); Sha256Hash getPrevBlockHash(); long getTimeSeconds(); Date getTime(); long getDifficultyTarget(); long getNonce(); List<Transaction> getTransactions(); Block createNextBlock(Address to, TransactionOutPoint prevOut); Block createNextBlock(Address to, BigInteger value); Block createNextBlock(Address to); Block createNextBlockWithCoinbase(byte[] pubKey, BigInteger coinbaseValue); static final int HEADER_SIZE; static final int MAX_BLOCK_SIZE; static final int MAX_BLOCK_SIGOPS; }### Answer: @Test public void testBadTransactions() throws Exception { Block block = new Block(params, blockBytes); Transaction tx1 = block.transactions.get(0); Transaction tx2 = block.transactions.get(1); block.transactions.set(0, tx2); block.transactions.set(1, tx1); try { block.verify(); fail(); } catch (VerificationException e) { } }
### Question: SeedPeers implements PeerDiscovery { public InetSocketAddress[] getPeers(long timeoutValue, TimeUnit timeoutUnit) throws PeerDiscoveryException { try { return allPeers(); } catch (UnknownHostException e) { throw new PeerDiscoveryException(e); } } SeedPeers(NetworkParameters params); InetSocketAddress getPeer(); InetSocketAddress[] getPeers(long timeoutValue, TimeUnit timeoutUnit); void shutdown(); static int[] seedAddrs; }### Answer: @Test public void getPeers_length() throws Exception{ SeedPeers seedPeers = new SeedPeers(NetworkParameters.prodNet()); InetSocketAddress[] addresses = seedPeers.getPeers(0, TimeUnit.SECONDS); assertThat(addresses.length, equalTo(SeedPeers.seedAddrs.length)); }
### Question: Block extends Message { private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException { ois.defaultReadObject(); hash = null; } Block(NetworkParameters params); Block(NetworkParameters params, byte[] payloadBytes); Block(NetworkParameters params, byte[] payloadBytes, boolean parseLazy, boolean parseRetain, int length); BigInteger getBlockInflation(int height); int getOptimalEncodingMessageSize(); void ensureParsed(); void ensureParsedHeader(); void ensureParsedTransactions(); byte[] litecoinSerialize(); String getHashAsString(); String getScryptHashAsString(); Sha256Hash getHash(); Sha256Hash getScryptHash(); BigInteger getWork(); Block cloneAsHeader(); @Override String toString(); BigInteger getDifficultyTargetAsInteger(); void verifyHeader(); void verifyTransactions(); void verify(); @Override boolean equals(Object o); @Override int hashCode(); Sha256Hash getMerkleRoot(); void addTransaction(Transaction t); long getVersion(); Sha256Hash getPrevBlockHash(); long getTimeSeconds(); Date getTime(); long getDifficultyTarget(); long getNonce(); List<Transaction> getTransactions(); Block createNextBlock(Address to, TransactionOutPoint prevOut); Block createNextBlock(Address to, BigInteger value); Block createNextBlock(Address to); Block createNextBlockWithCoinbase(byte[] pubKey, BigInteger coinbaseValue); static final int HEADER_SIZE; static final int MAX_BLOCK_SIZE; static final int MAX_BLOCK_SIGOPS; }### Answer: @Test public void testJavaSerialiazation() throws Exception { Block block = new Block(params, blockBytes); Transaction tx = block.transactions.get(1); ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(tx); oos.close(); byte[] javaBits = bos.toByteArray(); ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(javaBits)); Transaction tx2 = (Transaction) ois.readObject(); ois.close(); assertEquals(tx, tx2); }
### Question: Peer { public void addEventListener(PeerEventListener listener) { eventListeners.add(listener); } Peer(NetworkParameters params, AbstractBlockChain chain, VersionMessage ver); Peer(NetworkParameters params, AbstractBlockChain chain, VersionMessage ver, MemoryPool mempool); Peer(NetworkParameters params, AbstractBlockChain blockChain, String thisSoftwareName, String thisSoftwareVersion); void addEventListener(PeerEventListener listener); boolean removeEventListener(PeerEventListener listener); @Override String toString(); PeerHandler getHandler(); ListenableFuture<List<Transaction>> downloadDependencies(Transaction tx); ListenableFuture<Block> getBlock(Sha256Hash blockHash); ListenableFuture<Transaction> getPeerMempoolTransaction(Sha256Hash hash); void setDownloadParameters(long secondsSinceEpoch, boolean useFilteredBlocks); void addWallet(Wallet wallet); void removeWallet(Wallet wallet); ChannelFuture sendMessage(Message m); void startBlockChainDownload(); ListenableFuture<Long> ping(); long getLastPingTime(); long getPingTime(); int getPeerBlockHeightDifference(); boolean getDownloadData(); void setDownloadData(boolean downloadData); PeerAddress getAddress(); VersionMessage getPeerVersionMessage(); VersionMessage getVersionMessage(); long getBestHeight(); ChannelFuture setMinProtocolVersion(int minProtocolVersion); void setBloomFilter(BloomFilter filter); BloomFilter getBloomFilter(); }### Answer: @Test public void testAddEventListener() throws Exception { control.replay(); connect(); PeerEventListener listener = new AbstractPeerEventListener(); peer.addEventListener(listener); assertTrue(peer.removeEventListener(listener)); assertFalse(peer.removeEventListener(listener)); }
### Question: LitecoinURI { public String getLabel() { return (String) parameterMap.get(FIELD_LABEL); } LitecoinURI(String uri); LitecoinURI(NetworkParameters params, String input); Address getAddress(); BigInteger getAmount(); String getLabel(); String getMessage(); Object getParameterByName(String name); @Override String toString(); static String convertToLitecoinURI(Address address, BigInteger amount, String label, String message); static String convertToLitecoinURI(String address, BigInteger amount, String label, String message); static final String FIELD_MESSAGE; static final String FIELD_LABEL; static final String FIELD_AMOUNT; static final String FIELD_ADDRESS; static final String LITECOIN_SCHEME; }### Answer: @Test public void testGood_Label() throws LitecoinURIParseException { testObject = new LitecoinURI(NetworkParameters.prodNet(), LitecoinURI.LITECOIN_SCHEME + ":" + PRODNET_GOOD_ADDRESS + "?label=Hello%20World"); assertEquals("Hello World", testObject.getLabel()); }
### Question: LitecoinURI { @Override public String toString() { StringBuilder builder = new StringBuilder("LitecoinURI["); boolean first = true; for (Map.Entry<String, Object> entry : parameterMap.entrySet()) { if (first) { first = false; } else { builder.append(","); } builder.append("'").append(entry.getKey()).append("'=").append("'").append(entry.getValue().toString()).append("'"); } builder.append("]"); return builder.toString(); } LitecoinURI(String uri); LitecoinURI(NetworkParameters params, String input); Address getAddress(); BigInteger getAmount(); String getLabel(); String getMessage(); Object getParameterByName(String name); @Override String toString(); static String convertToLitecoinURI(Address address, BigInteger amount, String label, String message); static String convertToLitecoinURI(String address, BigInteger amount, String label, String message); static final String FIELD_MESSAGE; static final String FIELD_LABEL; static final String FIELD_AMOUNT; static final String FIELD_ADDRESS; static final String LITECOIN_SCHEME; }### Answer: @Test public void testGood_Combinations() throws LitecoinURIParseException { testObject = new LitecoinURI(NetworkParameters.prodNet(), LitecoinURI.LITECOIN_SCHEME + ":" + PRODNET_GOOD_ADDRESS + "?amount=9876543210&label=Hello%20World&message=Be%20well"); assertEquals( "LitecoinURI['address'='LQz2pJYaeqntA9BFB8rDX5AL2TTKGd5AuN','amount'='987654321000000000','label'='Hello World','message'='Be well']", testObject.toString()); }
### Question: CloudNoticeDAO { public List<Recipient> getRecipients() { return mapper.scan(Recipient.class, new DynamoDBScanExpression()); } CloudNoticeDAO(boolean local); List<Recipient> getRecipients(); void saveRecipient(Recipient recip); void deleteRecipient(Recipient recip); void shutdown(); static final String TABLE_NAME; }### Answer: @Test public void getRecipients() { dao.getRecipients(); }
### Question: CloudNoticeDAO { public void deleteRecipient(Recipient recip) { mapper.delete(recip); } CloudNoticeDAO(boolean local); List<Recipient> getRecipients(); void saveRecipient(Recipient recip); void deleteRecipient(Recipient recip); void shutdown(); static final String TABLE_NAME; }### Answer: @Test public void deleteRecipient() { Recipient recip = new Recipient("SMS", "[email protected]"); dao.saveRecipient(recip); Assert.assertEquals(1, dao.getRecipients().size()); dao.deleteRecipient(recip); Assert.assertEquals(0, dao.getRecipients().size()); }
### Question: DateCalculator { public DateCalculatorResult calculate(String text) { final DateCalcExpressionParser parser = new DateCalcExpressionParser(); final Queue<Token> tokens = parser.parse(text); try { if (!tokens.isEmpty()) { if (tokens.peek() instanceof DateToken) { return handleDateExpression(tokens); } else if (tokens.peek() instanceof TimeToken) { return handleTimeExpression(tokens); } } } catch (UnsupportedTemporalTypeException utte) { throw new DateCalcException(utte.getLocalizedMessage()); } throw new DateCalcException("An invalid expression was given: " + text); } DateCalculatorResult calculate(String text); }### Answer: @Test public void testDateMath() { final String expression = "today + 2 weeks 3 days"; DateCalculatorResult result = dc.calculate(expression); Assert.assertNotNull(result.getDate().get(), "'" + expression + "' should have returned a result."); } @Test public void testDateDiff() { final String expression = "2016/07/04 - 1776/07/04"; DateCalculatorResult result = dc.calculate(expression); Assert.assertEquals(result.getPeriod().get(), Period.of(240,0,0), "'" + expression + "' should..."); } @Test public void timeMath() { final String expression = "12:37 + 42 m"; DateCalculatorResult result = dc.calculate(expression); Assert.assertEquals(result.getTime().get(), LocalTime.parse("13:19")); } @Test public void timeDiff() { final String expression = "12:37 - 7:15"; DateCalculatorResult result = dc.calculate(expression); Assert.assertEquals(result.getDuration().get().toHoursPart(), 5); Assert.assertEquals(result.getDuration().get().toMinutesPart(), 22); }
### Question: Book { public void addAuthor(Author author) { authors.add(createAuthorRef(author)); } void addAuthor(Author author); }### Answer: @Test public void booksAndAuthors() { Author author = new Author(); author.name = "Greg L. Turnquist"; author = authorRepo.save(author); Book book = new Book(); book.title = "Spring Boot"; book.addAuthor(author); bookRepo.save(book); bookRepo.deleteAll(); assertThat(authorRepo.count()).isEqualTo(1); }
### Question: EnumeratedBerDecoder implements BerDecoder { @Override public Value decode( @NotNull ReaderContext context ) throws IOException, Asn1Exception { assert context.getType().getFamily() == Family.ENUMERATED; return context.getType().optimize( context.getScope(), IntegerBerDecoder.readInteger( context.getReader(), context.getLength() ) ); } @Override Value decode( @NotNull ReaderContext context ); }### Answer: @Test( expected = AssertionError.class ) public void testDecode_fail_type() throws Exception { Scope scope = CoreModule.getInstance().createScope(); Type type = UniversalType.INTEGER.ref().resolve( scope ); try( AbstractBerReader reader = mock( DefaultBerReader.class ) ) { Tag tag = ( (TagEncoding)type.getEncoding( EncodingInstructions.TAG ) ).toTag( false ); new EnumeratedBerDecoder().decode( new ReaderContext( reader, scope, type, tag, -1, false ) ); fail( "Must fail" ); } }
### Question: Elements implements Constraint { public Elements( @NotNull Constraint unions, @Nullable Constraint exclusion ) { this.unions = unions; this.exclusion = exclusion; } Elements( @NotNull Constraint unions, @Nullable Constraint exclusion ); @Override void check( Scope scope, Ref<Value> valueRef ); @NotNull @Override Constraint copyForType( @NotNull Scope scope, @NotNull Type type ); @NotNull @Override Value getMinimumValue( @NotNull Scope scope ); @NotNull @Override Value getMaximumValue( @NotNull Scope scope ); @Override String toString(); @Override void setScopeOptions( Scope scope ); @Override void assertConstraintTypes( Collection<ConstraintType> allowedTypes ); @Override void collectValues( @NotNull Collection<Value> values, @NotNull Collection<Kind> requiredKinds ); }### Answer: @Test public void doTest() throws Exception { Asn1Factory factory = new DefaultAsn1Factory(); Module module = factory.types().dummyModule(); DefinedType type = factory.types().define( "MyInt", factory.types().builtin( "INTEGER" ), null ); module.validate(); ConstraintTemplate e = factory.constraints().elements( constraint, except ); boolean actual = ConstraintTestUtils.checkConstraint( e, factory.values().integer( 1 ), type, module.createScope() ); Assert.assertEquals( title + ": failed", expectedResult, actual ); }
### Question: ElementSetSpec implements Constraint { public ElementSetSpec( List<Constraint> unions ) { this.unions = new ArrayList<>( unions ); } ElementSetSpec( List<Constraint> unions ); @Override void check( Scope scope, Ref<Value> valueRef ); @NotNull @Override Value getMinimumValue( @NotNull Scope scope ); @NotNull @Override Value getMaximumValue( @NotNull Scope scope ); @Override String toString(); @NotNull @Override Constraint copyForType( @NotNull Scope scope, @NotNull Type type ); @Override void setScopeOptions( Scope scope ); @Override void assertConstraintTypes( Collection<ConstraintType> allowedTypes ); @Override void collectValues( @NotNull Collection<Value> values, @NotNull Collection<Kind> requiredKinds ); }### Answer: @Test public void doTest() { Asn1Factory factory = new DefaultAsn1Factory(); Module module = factory.types().dummyModule(); DefinedType type = factory.types().define( "MyInt", factory.types().builtin( "INTEGER" ), null ); ConstraintTemplate specs = unions == null ? factory.constraints().elementSetSpec( exclusion ) : factory.constraints().elementSetSpec( unions ); boolean actual = ConstraintTestUtils.checkConstraint( specs, factory.values().integer( 1 ), type, module.createScope() ); Assert.assertEquals( title + ": failed", expectedResult, actual ); }
### Question: NullBerDecoder implements BerDecoder { @Override public Value decode( @NotNull ReaderContext context ) { assert context.getType().getFamily() == Family.NULL; assert context.getLength() == 0; return NullValue.INSTANCE; } @Override Value decode( @NotNull ReaderContext context ); }### Answer: @Test( expected = AssertionError.class ) public void testDecode_fail_length() throws Exception { Scope scope = CoreModule.getInstance().createScope(); Type type = UniversalType.NULL.ref().resolve( scope ); try( AbstractBerReader reader = mock( DefaultBerReader.class ) ) { Tag tag = ( (TagEncoding)type.getEncoding( EncodingInstructions.TAG ) ).toTag( false ); new NullBerDecoder().decode( new ReaderContext( reader, scope, type, tag, 1, false ) ); fail( "Must fail" ); } } @Test( expected = AssertionError.class ) public void testDecode_fail_type() throws Exception { Scope scope = CoreModule.getInstance().createScope(); Type type = UniversalType.INTEGER.ref().resolve( scope ); try( AbstractBerReader reader = mock( DefaultBerReader.class ) ) { Tag tag = ( (TagEncoding)type.getEncoding( EncodingInstructions.TAG ) ).toTag( false ); new NullBerDecoder().decode( new ReaderContext( reader, scope, type, tag, 0, false ) ); fail( "Must fail" ); } }
### Question: RefUtils { public static void assertTypeRef( String name ) { if( !isTypeRef( name ) ) throw new IllegalArgumentException( "Not a type reference: " + name ); } private RefUtils(); static void assertTypeRef( String name ); static boolean isSameAsDefaultValue( Scope scope, ComponentType component, Value resolve ); static boolean isTypeRef( CharSequence name ); static void assertValueRef( String name ); static boolean isValueRef( CharSequence name ); static boolean isIriValue( CharSequence value ); static void assertIriValue( String value ); static void resolutionValidate( Scope scope, Validation validation ); static Value toBasicValue( Scope scope, Ref<Value> ref ); static boolean isValueRef( @Nullable Ref<?> ref ); static boolean isTypeRef( @Nullable Ref<?> ref ); }### Answer: @Test( expected = IllegalArgumentException.class ) public void testNotTypeRef() { RefUtils.assertTypeRef( "a" ); }
### Question: RefUtils { public static void assertValueRef( String name ) { if( !isValueRef( name ) ) throw new IllegalArgumentException( "Not a value reference: " + name ); } private RefUtils(); static void assertTypeRef( String name ); static boolean isSameAsDefaultValue( Scope scope, ComponentType component, Value resolve ); static boolean isTypeRef( CharSequence name ); static void assertValueRef( String name ); static boolean isValueRef( CharSequence name ); static boolean isIriValue( CharSequence value ); static void assertIriValue( String value ); static void resolutionValidate( Scope scope, Validation validation ); static Value toBasicValue( Scope scope, Ref<Value> ref ); static boolean isValueRef( @Nullable Ref<?> ref ); static boolean isTypeRef( @Nullable Ref<?> ref ); }### Answer: @Test( expected = IllegalArgumentException.class ) public void testNotValueRef() { RefUtils.assertValueRef( "A" ); }
### Question: RefUtils { public static boolean isSameAsDefaultValue( Scope scope, ComponentType component, Value resolve ) throws ResolutionException { if( component.getDefaultValue() == null ) return false; resolve = toBasicValue( scope, resolve ); Value value = toBasicValue( scope, component.getDefaultValue() ); return resolve.isEqualTo( value ); } private RefUtils(); static void assertTypeRef( String name ); static boolean isSameAsDefaultValue( Scope scope, ComponentType component, Value resolve ); static boolean isTypeRef( CharSequence name ); static void assertValueRef( String name ); static boolean isValueRef( CharSequence name ); static boolean isIriValue( CharSequence value ); static void assertIriValue( String value ); static void resolutionValidate( Scope scope, Validation validation ); static Value toBasicValue( Scope scope, Ref<Value> ref ); static boolean isValueRef( @Nullable Ref<?> ref ); static boolean isTypeRef( @Nullable Ref<?> ref ); }### Answer: @Test public void testSameAsDefault() throws Exception { MyIntegerValue value = new MyIntegerValue(); assertTrue( "Must be true", RefUtils.isSameAsDefaultValue( new MyScope(), new MyAbstractComponentType( value ), value ) ); }
### Question: HexUtils { @SuppressWarnings( "MagicNumber" ) public static String toHexString( byte[] array ) { if( ArrayUtils.isEmpty( array ) ) return ""; StringBuilder sb = new StringBuilder(); for( byte value : array ) { if( ( value & 0xF0 ) == 0 ) sb.append( '0' ); sb.append( Integer.toHexString( value & 0xFF ).toUpperCase() ); } return sb.toString(); } private HexUtils(); @SuppressWarnings( "MagicNumber" ) static String toHexString( byte[] array ); }### Answer: @Test public void testConversion() throws Exception { assertEquals( "Is not equal", "0A", HexUtils.toHexString( new byte[]{0x0A} ) ); assertEquals( "Is not equal", "0A0A", HexUtils.toHexString( new byte[]{0x0A, 0x0A} ) ); assertEquals( "Is not equal", "", HexUtils.toHexString( new byte[]{} ) ); }
### Question: CollectionUtils { @NotNull public static String convertToBString( Iterable<? extends Ref<Value>> valueList, int desiredSize ) { Collection<Long> values = new HashSet<>(); Long maxValue = 0L; for( Ref<Value> valueRef : valueList ) { NamedValue value = (NamedValue)valueRef; if( value.getReferenceKind() != Kind.INTEGER \|\| !value.toIntegerValue().isLong() ) throw new IllegalStateException(); Long longValue = value.toIntegerValue().asLong(); values.add( longValue ); maxValue = Math.max( maxValue, longValue ); } if( desiredSize > -1 ) { if( maxValue > ( desiredSize - 1 ) ) throw new IllegalArgumentException( "Unable to truncate data. Desired size is smaller than expected: current = " + ( maxValue + 1 ) + " desired = " + desiredSize ); maxValue = (long)desiredSize - 1; } StringBuilder sb = new StringBuilder(); sb.append( '\'' ); for( long value = 0; value <= maxValue; value++ ) sb.append( values.contains( value ) ? '1' : '0' ); sb.append( "'B" ); return sb.toString(); } private CollectionUtils(); @NotNull static String convertToBString( Iterable<? extends Ref<Value>> valueList, int desiredSize ); }### Answer: @Test public void testConversion() throws Exception { IntegerValue value = new MyIntegerValue(); MyScope scope = new MyScope(); MyNamedValue namedValue = new MyNamedValue( (IntegerValue)RefUtils.toBasicValue( scope, value ) ); String result = CollectionUtils.convertToBString( Collections.singletonList( namedValue ), 4 ); assertEquals( "Is not equals", "'0100'B", result ); assertEquals( "Must be equal", value, RefUtils.toBasicValue( scope, namedValue ) ); }
### Question: TemplateParameter implements Comparable<TemplateParameter> { public String getName() { if( reference instanceof TypeNameRef ) return ( (TypeNameRef)reference ).getName(); if( reference instanceof ValueNameRef ) return ( (ValueNameRef)reference ).getName(); throw new IllegalStateException(); } TemplateParameter( int index, @NotNull Ref<?> reference, @Nullable Ref<Type> governor ); int getIndex(); String getName(); @SuppressWarnings( "unchecked" ) Ref<T> getReference(); @Nullable Ref<Type> getGovernor(); boolean isTypeRef(); boolean isValueRef(); @SuppressWarnings( "unchecked" ) @Override boolean equals( Object obj ); @Override int hashCode(); @Override String toString(); @Override int compareTo( @NotNull TemplateParameter o ); }### Answer: @Test( expected = IllegalStateException.class ) public void testIllegalRef() throws Exception { TemplateParameter parameter = new TemplateParameter( 0, scope -> { throw new UnsupportedOperationException(); }, null ); parameter.getName(); fail( "Must fail" ); }
### Question: Template { public Template() { this( false ); } Template(); Template( boolean instance ); void addParameter( TemplateParameter parameter ); @Nullable TemplateParameter getParameter( @NotNull String name ); @NotNull TemplateParameter getParameter( int index ); int getParameterCount(); boolean isInstance(); }### Answer: @Test public void testTemplate() throws Exception { Template template = new Template(); assertEquals( "Parameter count must be 0", 0, template.getParameterCount() ); template.addParameter( new TemplateParameter( 0, new TypeNameRef( "A" ), null ) ); assertEquals( "Parameter count must be 1", 1, template.getParameterCount() ); assertNotNull( "Must not be null", template.getParameter( 0 ) ); assertNotNull( "Must not be null", template.getParameter( "A" ) ); assertFalse( "Must not be instance", template.isInstance() ); }
### Question: Template { @Nullable public TemplateParameter getParameter( @NotNull String name ) { return parameterMap.get( name ); } Template(); Template( boolean instance ); void addParameter( TemplateParameter parameter ); @Nullable TemplateParameter getParameter( @NotNull String name ); @NotNull TemplateParameter getParameter( int index ); int getParameterCount(); boolean isInstance(); }### Answer: @Test( expected = IllegalArgumentException.class ) public void testIllegalIndexGet() throws Exception { Template template = new Template(); template.getParameter( 1 ); fail( "Must fail" ); }
### Question: EnumTypeMapperFactory implements TypeMapperFactory { @SuppressWarnings( "unchecked" ) @Override public TypeMapper mapType( Type type, TypeMetadata metadata ) { if( !isSupportedFor( type ) ) throw new IllegalArgumentException( "Only enum types allowed" ); return mapEnum( (Class<Enum<?>>)type ); } EnumTypeMapperFactory( TypeMapperContext context, Asn1Factory factory ); @Override int getPriority(); @Override boolean isSupportedFor( Type type ); @SuppressWarnings( "unchecked" ) @Override TypeMapper mapType( Type type, TypeMetadata metadata ); }### Answer: @Test( expected = IllegalArgumentException.class ) public void testDuplicateFail() throws Exception { mapperFactory.mapType( Values.class, null ); fail( "Must fail" ); } @Test( expected = IllegalArgumentException.class ) public void testUnsupportedType() throws Exception { mapperFactory.mapType( Integer.class, null ); fail( "Must fail!" ); } @Test( expected = IllegalStateException.class ) public void testNoEnumConstantsFail() throws Exception { mapperFactory.mapType( ValuesEmpty.class, null ); fail( "Must fail" ); } @Test( expected = IllegalStateException.class ) public void testIllegalIndexes() throws Exception { mapperFactory.mapType( IllegalEnum.class, null ); fail( "Must fail" ); } @Test( expected = IllegalStateException.class ) public void testIllegalIndexes2() throws Exception { mapperFactory.mapType( IllegalEnum2.class, null ); fail( "Must fail" ); }
### Question: Introspector { @NotNull public JavaType introspect( Type type ) { if( typeMap.containsKey( type.getTypeName() ) ) return typeMap.get( type.getTypeName() ); if( type instanceof Class<?> ) return forClass( (Class<?>)type ); if( type instanceof ParameterizedType ) return forParameterized( (ParameterizedType)type ); if( type instanceof TypeVariable<?> ) { JavaType javaType = new JavaType( type ); typeMap.put( type.getTypeName(), javaType ); return javaType; } throw new UnsupportedOperationException(); } @NotNull JavaType introspect( Type type ); }### Answer: @Test public void testIntrospection() throws Exception { Introspector introspector = new Introspector(); JavaType type = introspector.introspect( Element.class ); int k = 0; }
### Question: RealTypeMapper implements TypeMapper { @NotNull @Override public Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ) { if( isFloat() && isAssignableToFloat( value ) ) return factory.real( (Float)value ); if( isDouble() && isAssignableToDouble( value ) ) return factory.real( (Double)value ); if( isBigDecimal() && Objects.equals( value.getClass(), BigDecimal.class ) ) return factory.real( (BigDecimal)value ); throw new IllegalArgumentException( "Unable to convert value: " + value ); } RealTypeMapper( Class<?> realClass, NamedType asnType ); @Override Type getJavaType(); @Override NamedType getAsn1Type(); @NotNull @Override Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ); @NotNull @Override Object toJava( @NotNull Value value ); }### Answer: @Test( expected = IllegalArgumentException.class ) public void toAsn1Fails() throws Exception { TypeMapper mapper = new RealTypeMapper( double.class, REAL ); mapper.toAsn1( FACTORY, true ); fail( "Must fail" ); }
### Question: RealTypeMapper implements TypeMapper { @NotNull @Override public Object toJava( @NotNull Value value ) { if( value.getKind() != Kind.REAL ) throw new IllegalArgumentException( "Unable to handle value of kind: " + value.getKind() ); RealValue rv = value.toRealValue(); if( isFloat() ) return rv.asFloat(); if( isDouble() ) return rv.asDouble(); if( isBigDecimal() ) return rv.asBigDecimal(); throw new UnsupportedOperationException(); } RealTypeMapper( Class<?> realClass, NamedType asnType ); @Override Type getJavaType(); @Override NamedType getAsn1Type(); @NotNull @Override Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ); @NotNull @Override Object toJava( @NotNull Value value ); }### Answer: @Test( expected = IllegalArgumentException.class ) public void toJavaFails() throws Exception { TypeMapper mapper = new RealTypeMapper( double.class, REAL ); mapper.toJava( BooleanValue.TRUE ); fail( "Must fail" ); }
### Question: StringTypeMapper implements TypeMapper { @NotNull @Override public Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ) { if( !javaType.isAssignableFrom( value.getClass() ) ) throw new IllegalArgumentException( "Unable to convert value: " + value ); return factory.cString( (String)value ); } StringTypeMapper( Class<?> javaType, NamedType asnType ); @Override Type getJavaType(); @Override NamedType getAsn1Type(); @NotNull @Override Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ); @NotNull @Override Object toJava( @NotNull Value value ); }### Answer: @Test( expected = IllegalArgumentException.class ) public void toAsn1Fails() throws Exception { TypeMapper mapper = new StringTypeMapper( String.class, UTF8_STRING ); mapper.toAsn1( FACTORY, 1L ); fail( "Must fail" ); }
### Question: StringTypeMapper implements TypeMapper { @NotNull @Override public Object toJava( @NotNull Value value ) { if( value.getKind() != Kind.C_STRING ) throw new IllegalArgumentException( "Unable to convert value of kind: " + value.getKind() ); return value.toStringValue().asString(); } StringTypeMapper( Class<?> javaType, NamedType asnType ); @Override Type getJavaType(); @Override NamedType getAsn1Type(); @NotNull @Override Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ); @NotNull @Override Object toJava( @NotNull Value value ); }### Answer: @Test( expected = IllegalArgumentException.class ) public void toJavaFails() throws Exception { TypeMapper mapper = new StringTypeMapper( String.class, UTF8_STRING ); mapper.toJava( BooleanValue.TRUE ); fail( "Must fail" ); }
### Question: IntegerTypeMapper implements TypeMapper { @NotNull @Override public Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ) { if( isByte() && isAssignableToByte( value ) ) return factory.integer( (Byte)value ); if( isShort() && isAssignableToShort( value ) ) return factory.integer( (Short)value ); if( isInteger() && isAssignableToInt( value ) ) return factory.integer( (Integer)value ); if( isLong() && isAssignableToLong( value ) ) return factory.integer( (Long)value ); if( isBigInteger() && Objects.equals( value.getClass(), BigInteger.class ) ) return factory.integer( (BigInteger)value ); throw new IllegalArgumentException( "Unable to convert value: " + value ); } IntegerTypeMapper( Class<?> integerClass, NamedType asnType ); @Override Type getJavaType(); @Override NamedType getAsn1Type(); @NotNull @Override Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ); @NotNull @Override Object toJava( @NotNull Value value ); }### Answer: @Test( expected = IllegalArgumentException.class ) public void toAsn1Fails() throws Exception { TypeMapper mapper = new IntegerTypeMapper( Long.class, INTEGER ); mapper.toAsn1( FACTORY, true ); fail( "Must fail" ); }
### Question: IntegerTypeMapper implements TypeMapper { @NotNull @Override public Object toJava( @NotNull Value value ) { if( value.getKind() != Kind.INTEGER ) throw new IllegalArgumentException( "Unable to convert to integer value of kind: " + value.getKind() ); IntegerValue iv = value.toIntegerValue(); if( isByte() ) return (byte)iv.asInt(); if( isShort() ) return (short)iv.asInt(); if( isInteger() ) return iv.asInt(); if( isLong() ) return iv.asLong(); if( isBigInteger() ) return iv.asBigInteger(); throw new UnsupportedOperationException(); } IntegerTypeMapper( Class<?> integerClass, NamedType asnType ); @Override Type getJavaType(); @Override NamedType getAsn1Type(); @NotNull @Override Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ); @NotNull @Override Object toJava( @NotNull Value value ); }### Answer: @Test( expected = IllegalArgumentException.class ) public void toJavaFails() throws Exception { TypeMapper mapper = new IntegerTypeMapper( Long.class, INTEGER ); mapper.toJava( BooleanValue.TRUE ); fail( "Must fail" ); }
### Question: ByteArrayTypeMapper implements TypeMapper { @NotNull @Override public Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ) { if( !byte[].class.isAssignableFrom( value.getClass() ) ) throw new IllegalArgumentException( "Unable to convert value: " + value ); byte[] array = (byte[])value; return factory.byteArrayValue( array.length * 8, array ); } ByteArrayTypeMapper( Class<?> javaType, NamedType asnType ); @Override Type getJavaType(); @Override NamedType getAsn1Type(); @NotNull @Override Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ); @NotNull @Override Object toJava( @NotNull Value value ); }### Answer: @Test( expected = IllegalArgumentException.class ) public void toAsn1Fails() throws Exception { TypeMapper mapper = new ByteArrayTypeMapper( byte[].class, OCTET_STRING ); mapper.toAsn1( FACTORY, 1L ); fail( "Must fail" ); }
### Question: BitStringBerDecoder implements BerDecoder { @Override public Value decode( @NotNull ReaderContext context ) throws IOException, Asn1Exception { assert context.getType().getFamily() == Family.BIT_STRING; assert !context.getTag().isConstructed(); if( context.getLength() == 0 ) return context.getValueFactory().emptyByteArray(); byte unusedBits = context.read(); if( unusedBits < 0 \|\| unusedBits > 7 ) throw new IllegalValueException( "Unused bits must be in range: [0,7]" ); if( context.getLength() == -1 ) return OctetStringBerDecoder.readByteArrayValueIndefinite( context.getReader(), unusedBits ); return OctetStringBerDecoder.readByteArrayValue( context.getReader(), context.getLength() - 1, unusedBits ); } @Override Value decode( @NotNull ReaderContext context ); }### Answer: @Test( expected = AssertionError.class ) public void testDecode_fail_type() throws Exception { Scope scope = CoreModule.getInstance().createScope(); Type type = UniversalType.INTEGER.ref().resolve( scope ); try( AbstractBerReader reader = mock( DefaultBerReader.class ) ) { Tag tag = ( (TagEncoding)type.getEncoding( EncodingInstructions.TAG ) ).toTag( false ); new BitStringBerDecoder().decode( new ReaderContext( reader, scope, type, tag, -1, false ) ); fail( "Must fail" ); } }
### Question: ByteArrayTypeMapper implements TypeMapper { @NotNull @Override public Object toJava( @NotNull Value value ) { if( value.getKind() != Kind.BYTE_ARRAY ) throw new IllegalArgumentException( "Unable to handle value of kind: " + value.getKind() ); return value.toByteArrayValue().asByteArray(); } ByteArrayTypeMapper( Class<?> javaType, NamedType asnType ); @Override Type getJavaType(); @Override NamedType getAsn1Type(); @NotNull @Override Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ); @NotNull @Override Object toJava( @NotNull Value value ); }### Answer: @Test( expected = IllegalArgumentException.class ) public void toJavaFails() throws Exception { TypeMapper mapper = new ByteArrayTypeMapper( byte[].class, OCTET_STRING ); mapper.toJava( BooleanValue.TRUE ); fail( "Must fail" ); }
### Question: DateTypeMapper implements TypeMapper { @NotNull @Override public Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ) { if( !javaType.isAssignableFrom( value.getClass() ) ) throw new IllegalArgumentException( "Unable to convert value: " + value ); if( isDate() ) return factory.timeValue( ( (Date)value ).toInstant() ); if( isInstant() ) return factory.timeValue( (Instant)value ); throw new UnsupportedOperationException(); } DateTypeMapper( Class<?> javaType, NamedType asnType ); @Override Type getJavaType(); @Override NamedType getAsn1Type(); @NotNull @Override Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ); @NotNull @Override Object toJava( @NotNull Value value ); }### Answer: @Test( expected = IllegalArgumentException.class ) public void toAsn1Fails() throws Exception { TypeMapper mapper = new DateTypeMapper( Instant.class, G_TIME ); mapper.toAsn1( FACTORY, 1L ); fail( "Must fail" ); }
### Question: DateTypeMapper implements TypeMapper { @NotNull @Override public Object toJava( @NotNull Value value ) { if( value.getKind() != Kind.TIME ) throw new IllegalArgumentException( "Unable to convert values of kind: " + value.getKind() ); Instant instant = value.toDateValue().asInstant(); if( isInstant() ) return instant; if( isDate() ) return Date.from( instant ); throw new UnsupportedOperationException(); } DateTypeMapper( Class<?> javaType, NamedType asnType ); @Override Type getJavaType(); @Override NamedType getAsn1Type(); @NotNull @Override Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ); @NotNull @Override Object toJava( @NotNull Value value ); }### Answer: @Test( expected = IllegalArgumentException.class ) public void toJavaFails() throws Exception { TypeMapper mapper = new DateTypeMapper( Instant.class, G_TIME ); mapper.toJava( BooleanValue.TRUE ); fail( "Must fail" ); }
### Question: BooleanTypeMapper implements TypeMapper { @NotNull @Override public Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ) { if( !isBooleanClass( value ) ) throw new IllegalArgumentException( "Unable to convert value: " + value ); if( Boolean.TRUE.equals( value ) ) return BooleanValue.TRUE; if( Boolean.FALSE.equals( value ) ) return BooleanValue.FALSE; throw new UnsupportedOperationException(); } BooleanTypeMapper( Class<?> booleanClass, NamedType asnType ); @Override Type getJavaType(); @Override NamedType getAsn1Type(); @NotNull @Override Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ); @NotNull @Override Object toJava( @NotNull Value value ); }### Answer: @Test public void toAsn1() throws Exception { BooleanTypeMapper mapper = new BooleanTypeMapper( boolean.class, BOOLEAN ); assertEquals( "Not equals", BooleanValue.TRUE, mapper.toAsn1( FACTORY, true ) ); assertEquals( "Not equals", BooleanValue.FALSE, mapper.toAsn1( FACTORY, false ) ); } @Test( expected = IllegalArgumentException.class ) public void toAsn1Fails() throws Exception { BooleanTypeMapper mapper = new BooleanTypeMapper( boolean.class, BOOLEAN ); mapper.toAsn1( FACTORY, 1L ); fail( "Must fail" ); }
### Question: BooleanTypeMapper implements TypeMapper { @NotNull @Override public Object toJava( @NotNull Value value ) { if( value.getKind() != Kind.BOOLEAN ) throw new IllegalArgumentException( "Unable to handle value of kind: " + value.getKind() ); if( Objects.equals( value, BooleanValue.TRUE ) ) return Boolean.TRUE; if( Objects.equals( value, BooleanValue.FALSE ) ) return Boolean.FALSE; throw new UnsupportedOperationException(); } BooleanTypeMapper( Class<?> booleanClass, NamedType asnType ); @Override Type getJavaType(); @Override NamedType getAsn1Type(); @NotNull @Override Value toAsn1( @NotNull ValueFactory factory, @NotNull Object value ); @NotNull @Override Object toJava( @NotNull Value value ); }### Answer: @Test public void toJava() throws Exception { BooleanTypeMapper mapper = new BooleanTypeMapper( boolean.class, BOOLEAN ); assertEquals( "Not equals", Boolean.TRUE, mapper.toJava( BooleanValue.TRUE ) ); assertEquals( "Not equals", Boolean.FALSE, mapper.toJava( BooleanValue.FALSE ) ); } @Test( expected = IllegalArgumentException.class ) public void toJavaFails() throws Exception { BooleanTypeMapper mapper = new BooleanTypeMapper( boolean.class, BOOLEAN ); mapper.toJava( FACTORY.integer( 1 ) ); fail( "Must fail" ); }
### Question: ObjectIDBerDecoder implements BerDecoder { @Override public Value decode( @NotNull ReaderContext context ) throws IOException, Asn1Exception { assert context.getType().getFamily() == Family.OID; assert context.getLength() > 0; List<Ref<Value>> list = new ArrayList<>(); int length = context.getLength(); while( length > 0 ) length = readObjectIDItem( context.getReader(), length, list ); ObjectIdentifierValue objectIdentifierValue = context.getValueFactory().objectIdentifier( list ); return context.getType().optimize( context.getScope(), objectIdentifierValue ); } @Override Value decode( @NotNull ReaderContext context ); }### Answer: @Test( expected = AssertionError.class ) public void testDecode_fail_type() throws Exception { Scope scope = CoreModule.getInstance().createScope(); Type type = UniversalType.INTEGER.ref().resolve( scope ); try( AbstractBerReader reader = mock( DefaultBerReader.class ) ) { Tag tag = ( (TagEncoding)type.getEncoding( EncodingInstructions.TAG ) ).toTag( false ); new ObjectIDBerDecoder().decode( new ReaderContext( reader, scope, type, tag, -1, false ) ); fail( "Must fail" ); } }
### Question: BooleanBerDecoder implements BerDecoder { @Override public Value decode( @NotNull ReaderContext context ) throws IOException { assert context.getType().getFamily() == Family.BOOLEAN; assert context.getLength() == 1; byte content = context.read(); return content == BerUtils.BOOLEAN_FALSE ? BooleanValue.FALSE : BooleanValue.TRUE; } @Override Value decode( @NotNull ReaderContext context ); }### Answer: @Test( expected = AssertionError.class ) public void testDecode_fail_type() throws Exception { Scope scope = CoreModule.getInstance().createScope(); Type type = UniversalType.INTEGER.ref().resolve( scope ); try( AbstractBerReader reader = mock( DefaultBerReader.class ) ) { Tag tag = ( (TagEncoding)type.getEncoding( EncodingInstructions.TAG ) ).toTag( false ); new BooleanBerDecoder().decode( new ReaderContext( reader, scope, type, tag, 1, false ) ); fail( "Must fail" ); } } @Test( expected = AssertionError.class ) public void testDecode_fail_length() throws Exception { Scope scope = CoreModule.getInstance().createScope(); Type type = UniversalType.BOOLEAN.ref().resolve( scope ); try( AbstractBerReader reader = mock( DefaultBerReader.class ) ) { Tag tag = ( (TagEncoding)type.getEncoding( EncodingInstructions.TAG ) ).toTag( false ); new BooleanBerDecoder().decode( new ReaderContext( reader, scope, type, tag, 2, false ) ); fail( "Must fail" ); } }
### Question: OctetStringBerDecoder implements BerDecoder { @Override public Value decode( @NotNull ReaderContext context ) throws IOException, Asn1Exception { assert context.getType().getFamily() == Family.OCTET_STRING; assert !context.getTag().isConstructed(); if( context.getLength() == -1 ) return readByteArrayValueIndefinite( context.getReader(), 0 ); if( context.getLength() == 0 ) return context.getValueFactory().emptyByteArray(); return readByteArrayValue( context.getReader(), context.getLength(), 0 ); } @Override Value decode( @NotNull ReaderContext context ); }### Answer: @Test( expected = AssertionError.class ) public void testDecode_fail_type() throws Exception { Scope scope = CoreModule.getInstance().createScope(); Type type = UniversalType.INTEGER.ref().resolve( scope ); try( AbstractBerReader reader = mock( DefaultBerReader.class ) ) { Tag tag = ( (TagEncoding)type.getEncoding( EncodingInstructions.TAG ) ).toTag( false ); new OctetStringBerDecoder().decode( new ReaderContext( reader, scope, type, tag, -1, false ) ); fail( "Must fail" ); } }
### Question: RealBerDecoder implements BerDecoder { @Override public Value decode( @NotNull ReaderContext context ) throws IOException { assert context.getType().getFamily() == Family.REAL; assert !context.getTag().isConstructed(); if( context.getLength() == 0 ) return context.getValueFactory().rZero(); byte first = context.read(); if( first == 0 ) return context.getValueFactory().rZero(); if( ( first & BerUtils.BYTE_SIGN_MASK ) != 0 ) return readBinary( context.getReader(), first, context.getLength() ); switch( first ) { case BerUtils.REAL_ISO_6093_NR1: case BerUtils.REAL_ISO_6093_NR2: case BerUtils.REAL_ISO_6093_NR3: return context.getValueFactory().real( readString( context.getReader(), context.getLength() - 1 ) ); case BerUtils.REAL_NEGATIVE_INF: return context.getValueFactory().rNegativeInfinity(); case BerUtils.REAL_POSITIVE_INF: return context.getValueFactory().rPositiveInfinity(); case BerUtils.REAL_NAN: return context.getValueFactory().rNan(); case BerUtils.REAL_MINUS_ZERO: return context.getValueFactory().rNegativeZero(); default: throw new IllegalStateException( String.format( "Illegal real configuration byte: %02X", first ) ); } } @Override Value decode( @NotNull ReaderContext context ); }### Answer: @Test( expected = AssertionError.class ) public void testDecode_fail_type() throws Exception { Scope scope = CoreModule.getInstance().createScope(); Type type = UniversalType.INTEGER.ref().resolve( scope ); try( AbstractBerReader reader = mock( DefaultBerReader.class ) ) { Tag tag = ( (TagEncoding)type.getEncoding( EncodingInstructions.TAG ) ).toTag( false ); new RealBerDecoder().decode( new ReaderContext( reader, scope, type, tag, -1, false ) ); fail( "Must fail" ); } }
### Question: IntegerBerEncoder implements BerEncoder { static byte[] toByteArray( long value ) { int size = calculateByteCount( value ); byte[] result = new byte[size]; for( int i = size - 1, position = 0; i >= 0; i--, position++ ) result[position] = getByteByIndex( value, i ); return result; } @Override void encode( @NotNull WriterContext context ); }### Answer: @Test public void testToByteArray_0() throws Exception { byte[] array = IntegerBerEncoder.toByteArray( 0L ); Assert.assertEquals( "Illegal array size", 1, array.length ); Assert.assertArrayEquals( "Arrays are different", new byte[]{0}, array ); } @Test public void testToByteArray_minus_1() throws Exception { byte[] array = IntegerBerEncoder.toByteArray( -1L ); Assert.assertEquals( "Illegal array size", 1, array.length ); Assert.assertArrayEquals( "Arrays are different", new byte[]{-1}, array ); } @Test public void testToByteArray_256() throws Exception { byte[] array = IntegerBerEncoder.toByteArray( 256L ); Assert.assertEquals( "Illegal array size", 2, array.length ); Assert.assertArrayEquals( "Arrays are different", new byte[]{1, 0}, array ); } @Test public void testToByteArray_300000() throws Exception { byte[] array = IntegerBerEncoder.toByteArray( 300000L ); Assert.assertEquals( "Illegal array size", 3, array.length ); Assert.assertArrayEquals( "Arrays are different", new byte[]{0x04, (byte)0x93, (byte)0xE0}, array ); }
### Question: IntegerBerDecoder implements BerDecoder { @Override public Value decode( @NotNull ReaderContext context ) throws IOException { assert context.getType().getFamily() == Family.INTEGER; assert context.getLength() >= 0; return readInteger( context.getReader(), context.getLength() ); } @Override Value decode( @NotNull ReaderContext context ); }### Answer: @Test( expected = AssertionError.class ) public void testDecode_fail_type() throws Exception { Scope scope = CoreModule.getInstance().createScope(); Type type = UniversalType.REAL.ref().resolve( scope ); try( AbstractBerReader reader = mock( DefaultBerReader.class ) ) { Tag tag = ( (TagEncoding)type.getEncoding( EncodingInstructions.TAG ) ).toTag( false ); new IntegerBerDecoder().decode( new ReaderContext( reader, scope, type, tag, -1, false ) ); fail( "Must fail" ); } }
### Question: NullBerEncoder implements BerEncoder { @Override public void encode( @NotNull WriterContext context ) throws IOException { assert context.getType().getFamily() == Family.NULL; assert context.getValue().getKind() == Kind.NULL; context.writeHeader( TAG, 0 ); } @Override void encode( @NotNull WriterContext context ); }### Answer: @Test public void testEncode_value_no_header() throws Exception { Scope scope = CoreModule.getInstance().createScope(); Type type = UniversalType.NULL.ref().resolve( scope ); Value value = NullValue.INSTANCE; try( AbstractBerWriter writer = mock( AbstractBerWriter.class ) ) { new NullBerEncoder().encode( new WriterContext( writer, scope, type, value, false ) ); verifyNoMoreInteractions( writer ); } } @Test public void testEncode_value_with_header() throws Exception { Scope scope = CoreModule.getInstance().createScope(); Type type = UniversalType.NULL.ref().resolve( scope ); Value value = NullValue.INSTANCE; try( AbstractBerWriter writer = mock( AbstractBerWriter.class ) ) { new NullBerEncoder().encode( new WriterContext( writer, scope, type, value, true ) ); verify( writer ).writeHeader( TAG, 0 ); verifyNoMoreInteractions( writer ); } } @Test( expected = AssertionError.class ) public void testEncode_fail_type() throws Exception { Scope scope = CoreModule.getInstance().createScope(); Type type = UniversalType.INTEGER.ref().resolve( scope ); Value value = NullValue.INSTANCE; try( AbstractBerWriter writer = mock( AbstractBerWriter.class ) ) { new NullBerEncoder().encode( new WriterContext( writer, scope, type, value, false ) ); fail( "Must fail" ); } } @Test( expected = AssertionError.class ) public void testEncode_fail_value() throws Exception { Scope scope = CoreModule.getInstance().createScope(); Type type = UniversalType.NULL.ref().resolve( scope ); Value value = BooleanValue.TRUE; try( AbstractBerWriter writer = mock( AbstractBerWriter.class ) ) { new NullBerEncoder().encode( new WriterContext( writer, scope, type, value, false ) ); fail( "Must fail" ); } }
### Question: GroupSyntaxObject implements SyntaxObject { @Override public String getText() { throw new UnsupportedOperationException(); } @Override Kind getKind(); @Override String getText(); void addObject( SyntaxObject object ); List<SyntaxObject> getObjects(); }### Answer: @Test( expected = UnsupportedOperationException.class ) public void testGetTextFail() { new GroupSyntaxObject().getText(); Assert.fail( "Exception was not thrown" ); }
### Question: GroupSyntaxObject implements SyntaxObject { public void addObject( SyntaxObject object ) { objects.add( object ); } @Override Kind getKind(); @Override String getText(); void addObject( SyntaxObject object ); List<SyntaxObject> getObjects(); }### Answer: @Test public void testAddObject() { GroupSyntaxObject group = new GroupSyntaxObject(); Assert.assertEquals( "Kind is not GROUP", Kind.GROUP, group.getKind() ); Assert.assertTrue( "Collection is not empty", group.getObjects().isEmpty() ); group.addObject( new SimpleSyntaxObject( Kind.KEYWORD, "VALUE" ) ); Assert.assertEquals( "Collection is not empty", 1, group.getObjects().size() ); }
### Question: FileQueueService { public QueueFile getQueueFile() { return this.queueFile; } @Autowired FileQueueService(@Value("${modum.tokenapp.email.queue-file-path}") String queueFilePath, @Autowired ObjectMapper objectMapper); FileQueueService(String queueFilePath); FileQueueService(); QueueFile getQueueFile(); ObjectMapper getObjectMapper(); synchronized void addConfirmationEmail(Investor investor, URI confirmationEmaiLink); synchronized void addSummaryEmail(Investor investor); synchronized Optional<Email> peekEmail(); synchronized void addEmail(Email email); }### Answer: @Test public void testFileQueue() throws IOException { FileQueueService fileQueueService = new FileQueueService(getTempFilePath()); fileQueueService.getQueueFile().add("test".getBytes()); assertThat(fileQueueService.getQueueFile().peek(), is("test".getBytes())); } @Test public void testFileQueueRecovering() throws IOException { String tempFile = getTempFilePath(); FileQueueService fileQueueService1 = new FileQueueService(tempFile); fileQueueService1.getQueueFile().add("test".getBytes()); FileQueueService fileQueueService2 = new FileQueueService(tempFile); assertThat(fileQueueService2.getQueueFile().peek(), is("test".getBytes())); }
### Question: SendEmailTask { public SendEmailTask() { } SendEmailTask(); @Scheduled(initialDelay = 10000, fixedRateString = "${modum.tokenapp.email.send-email-interval}") void sendEmail(); }### Answer: @Test public void testSendEmailTask() throws IOException, URISyntaxException { FileQueueService fileQueueService = new FileQueueService(getTempFilePath(), objectMapper); fileQueueService.addConfirmationEmail(new Investor().setEmail(INVESTOR_EMAIL), new URI(CONFIRMATION_EMAIL_URI)); Email email = fileQueueService.peekEmail().get(); assertThat(email.getInvestor().getEmail(), is(INVESTOR_EMAIL)); assertThat(email.getConfirmationEmaiLink().toASCIIString(), is(CONFIRMATION_EMAIL_URI)); }
### Question: Etherscan { public BigInteger getBalance(String address) throws IOException { String s = "https: "?module=account" + "&action=balance" + "&address=" + address + "&tag=latest" + "&apikey="+apiKey; HttpHeaders headers = new HttpHeaders(); headers.set("User-Agent", options.getUserAgent()); ResponseEntity<String> res = restTemplate.exchange(s, HttpMethod.GET, new HttpEntity<>(null, headers), String.class); ObjectMapper objectMapper = new ObjectMapper(); ReturnSingleValue retVal = objectMapper.readValue(res.getBody(), ReturnSingleValue.class); return new BigInteger(retVal.result); } BigInteger getBalance(String address); List<Triple<Date,Long,Long>> getTxEth(String address); BigInteger get20Balances(String... contract); BigInteger get20Balances(List<String> contract); long getCurrentBlockNr(); BigInteger getBalances(List<String> contract); }### Answer: @Test public void testConnect1() throws IOException { String balance = etherscan.getBalance("0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae").toString(); System.out.println("balance: "+balance); }
### Question: Etherscan { public BigInteger get20Balances(String... contract) throws IOException { return get20Balances(Arrays.asList(contract)); } BigInteger getBalance(String address); List<Triple<Date,Long,Long>> getTxEth(String address); BigInteger get20Balances(String... contract); BigInteger get20Balances(List<String> contract); long getCurrentBlockNr(); BigInteger getBalances(List<String> contract); }### Answer: @Test public void testConnect2() throws IOException { String balance = etherscan.get20Balances("0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae", "0x25d96310cd6694d88b9c6803be09511597c0a630").toString(); System.out.println("balance: "+balance); }
### Question: Etherscan { public long getCurrentBlockNr() throws IOException { String s = "https: "?module=proxy" + "&action=eth_blockNumber" + "&apikey="+apiKey; HttpHeaders headers = new HttpHeaders(); headers.set("User-Agent", options.getUserAgent()); ResponseEntity<String> res = restTemplate.exchange(s, HttpMethod.GET, new HttpEntity<>(null, headers), String.class); ObjectMapper objectMapper = new ObjectMapper(); ReturnBlock retVal = objectMapper.readValue(res.getBody(), ReturnBlock.class); return Long.parseLong(retVal.result.substring(2), 16); } BigInteger getBalance(String address); List<Triple<Date,Long,Long>> getTxEth(String address); BigInteger get20Balances(String... contract); BigInteger get20Balances(List<String> contract); long getCurrentBlockNr(); BigInteger getBalances(List<String> contract); }### Answer: @Test public void testBlockNr() throws IOException { long bl1 = blockr.getCurrentBlockNr(); long bl2 = etherscan.getCurrentBlockNr(); System.out.println("ret: "+bl1 +"/"+bl2); }
### Question: BerOctetString { public int encode(BerByteArrayOutputStream berOStream, boolean explicit) throws IOException { berOStream.write(octetString); int codeLength = octetString.length; codeLength += BerLength.encodeLength(berOStream, codeLength); if (explicit) { codeLength += id.encode(berOStream); } return codeLength; } BerOctetString(); BerOctetString(byte[] octetString); int encode(BerByteArrayOutputStream berOStream, boolean explicit); int decode(InputStream iStream, boolean explicit); @Override String toString(); final static BerIdentifier identifier; public byte[] octetString; }### Answer: @Test public void explicitEncoding() throws IOException { BerByteArrayOutputStream berStream = new BerByteArrayOutputStream(50); byte[] byteArray = new byte[] { 0x01, 0x02, 0x03 }; BerOctetString asn1OctetString = new BerOctetString(byteArray); int length = asn1OctetString.encode(berStream, true); Assert.assertEquals(5, length); byte[] expectedBytes = new byte[] { 0x04, 0x03, 0x01, 0x02, 0x03 }; Assert.assertArrayEquals(expectedBytes, berStream.getArray()); }
### Question: BerOctetString { public int decode(InputStream iStream, boolean explicit) throws IOException { int codeLength = 0; if (explicit) { codeLength += id.decodeAndCheck(iStream); } BerLength length = new BerLength(); codeLength += length.decode(iStream); octetString = new byte[length.val]; if (length.val != 0) { if (iStream.read(octetString, 0, length.val) < length.val) { throw new IOException("Error Decoding BerOctetString"); } codeLength += length.val; } return codeLength; } BerOctetString(); BerOctetString(byte[] octetString); int encode(BerByteArrayOutputStream berOStream, boolean explicit); int decode(InputStream iStream, boolean explicit); @Override String toString(); final static BerIdentifier identifier; public byte[] octetString; }### Answer: @Test public void explicitDecoding() throws IOException { byte[] byteCode = new byte[] { 0x04, 0x00 }; ByteArrayInputStream berInputStream = new ByteArrayInputStream(byteCode); BerOctetString asn1OctetString = new BerOctetString(); asn1OctetString.decode(berInputStream, true); Assert.assertEquals(0, asn1OctetString.octetString.length); }
### Question: BerObjectIdentifier { public int encode(BerByteArrayOutputStream berOStream, boolean explicit) throws IOException { int codeLength; if (code != null) { codeLength = code.length; for (int i = code.length - 1; i >= 0; i--) { berOStream.write(code[i]); } } else { int firstSubidentifier = 40 * objectIdentifierComponents[0] + objectIdentifierComponents[1]; int subidentifier; codeLength = 0; for (int i = (objectIdentifierComponents.length - 1); i > 0; i--) { if (i == 1) { subidentifier = firstSubidentifier; } else { subidentifier = objectIdentifierComponents[i]; } int subIDLength = 1; while (subidentifier > (Math.pow(2, (7 * subIDLength)) - 1)) { subIDLength++; } berOStream.write(subidentifier & 0x7f); for (int j = 1; j <= (subIDLength - 1); j++) { berOStream.write(((subidentifier >> (7 * j)) & 0xff) \| 0x80); } codeLength += subIDLength; } codeLength += BerLength.encodeLength(berOStream, codeLength); } if (explicit) { codeLength += id.encode(berOStream); } return codeLength; } BerObjectIdentifier(); BerObjectIdentifier(byte[] code); BerObjectIdentifier(int[] objectIdentifierComponents); int encode(BerByteArrayOutputStream berOStream, boolean explicit); int decode(InputStream iStream, boolean explicit); @Override String toString(); final static BerIdentifier identifier; public byte[] code; public int[] objectIdentifierComponents; }### Answer: @Test public void explicitEncoding() throws IOException { BerByteArrayOutputStream berBAOStream = new BerByteArrayOutputStream(50); BerObjectIdentifier oi = new BerObjectIdentifier(objectIdentifierComponents); int length = oi.encode(berBAOStream, true); Assert.assertEquals(7, length); Assert.assertArrayEquals(expectedBytes, berBAOStream.getArray()); }
### Question: BerLength { public static int encodeLength(BerByteArrayOutputStream berOStream, int length) throws IOException { if (length <= 127) { berOStream.write((byte) length); return 1; } else { int numLengthBytes = 1; while (((int) (Math.pow(2, 8 * numLengthBytes) - 1)) < length) { numLengthBytes++; } for (int i = 0; i < numLengthBytes; i++) { berOStream.write((length >> 8 * i) & 0xff); } berOStream.write(0x80 \| numLengthBytes); return 1 + numLengthBytes; } } BerLength(); int decode(InputStream iStream); static int encodeLength(BerByteArrayOutputStream berOStream, int length); public int val; }### Answer: @Test public void encodeLength() throws IOException { BerByteArrayOutputStream berOStream = new BerByteArrayOutputStream(50); int codedLength = BerLength.encodeLength(berOStream, 128); Assert.assertEquals(2, codedLength); byte[] expectedBytes = new byte[] { (byte) 0x81, (byte) 128 }; Assert.assertArrayEquals(expectedBytes, berOStream.getArray()); } @Test public void encodeLength2() throws IOException { BerByteArrayOutputStream berOStream = new BerByteArrayOutputStream(50); int codedLength = BerLength.encodeLength(berOStream, 128); Assert.assertEquals(2, codedLength); byte[] expectedBytes = new byte[] { (byte) 0x81, (byte) 128 }; Assert.assertArrayEquals(expectedBytes, berOStream.getArray()); }
### Question: BerLength { public int decode(InputStream iStream) throws IOException { val = iStream.read(); int length = 1; if ((val & 0x80) != 0) { int lengthLength = val & 0x7f; if (lengthLength == 0) { val = -1; return 1; } if (lengthLength > 4) { throw new IOException("Length is out of bound!"); } val = 0; byte[] byteCode = new byte[lengthLength]; if (iStream.read(byteCode, 0, lengthLength) == -1) { throw new IOException("Error Decoding ASN1Integer"); } length += lengthLength; for (int i = 0; i < lengthLength; i++) { val \|= (byteCode[i] & 0xff) << (8 * (lengthLength - i - 1)); } } return length; } BerLength(); int decode(InputStream iStream); static int encodeLength(BerByteArrayOutputStream berOStream, int length); public int val; }### Answer: @Test public void explicitDecoding() throws IOException { byte[] byteCode = new byte[] { (byte) 0x81, (byte) 128 }; ByteArrayInputStream berInputStream = new ByteArrayInputStream(byteCode); BerLength berLength = new BerLength(); berLength.decode(berInputStream); Assert.assertEquals(128, berLength.val); }
### Question: Functions { public static <T> List<T> myFilter(List<T> list, MyPredicate<T> myPredicate) { ArrayList<T> result = new ArrayList<>(); for (T t : list) { if (myPredicate.test(t)) result.add(t); } return result; } static List<T> myFilter(List<T> list, MyPredicate<T> myPredicate); static List<R> myMap(List<T> list, MyFunction<T, R> myFunction); static List<R> myFlatMap(List<T> list, MyFunction<T, List<R>> myFunction); static void myForEach(List<T> list, MyConsumer<T> myConsumer); static List<T> myGenerate(MySupplier<T> supplier, int count); }### Answer: @Test public void testMyFilter() { List<Integer> numbers = Arrays.asList(4, 5, 7, 8, 10, 11, 14, 15); List<Integer> result = Functions.myFilter(numbers, item -> item % 2 == 0); assertEquals(Arrays.asList(4, 8, 10, 14), result); } @Test public void testClosuresAvoidRepeats() { List<String> names = Arrays.asList("Foo", "Ramen", "Naan", "Ravioli"); System.out.println(Functions.myFilter(names, stringHasSizeOf(4))); System.out.println(Functions.myFilter(names, stringHasSizeOf(2))); }
### Question: Functions { public static <T> List<T> myGenerate(MySupplier<T> supplier, int count) { List<T> result = new ArrayList<>(); for (int i = 0; i < count; i++) { result.add(supplier.get()); } return result; } static List<T> myFilter(List<T> list, MyPredicate<T> myPredicate); static List<R> myMap(List<T> list, MyFunction<T, R> myFunction); static List<R> myFlatMap(List<T> list, MyFunction<T, List<R>> myFunction); static void myForEach(List<T> list, MyConsumer<T> myConsumer); static List<T> myGenerate(MySupplier<T> supplier, int count); }### Answer: @Test public void testMyGenerate() { List<LocalDateTime> localDateTimes = Functions.myGenerate(() -> { try { Thread.sleep(1000); } catch (InterruptedException e) { } return LocalDateTime.now(); }, 10); System.out.println(localDateTimes); }
### Question: Functions { public static <T, R> List<R> myFlatMap(List<T> list, MyFunction<T, List<R>> myFunction) { ArrayList<R> result = new ArrayList<>(); for (T t : list) { List<R> application = myFunction.apply(t); result.addAll(application); } return result; } static List<T> myFilter(List<T> list, MyPredicate<T> myPredicate); static List<R> myMap(List<T> list, MyFunction<T, R> myFunction); static List<R> myFlatMap(List<T> list, MyFunction<T, List<R>> myFunction); static void myForEach(List<T> list, MyConsumer<T> myConsumer); static List<T> myGenerate(MySupplier<T> supplier, int count); }### Answer: @Test public void testMyFlatMap() { List<Integer> numbers = Arrays.asList(4, 5, 7, 8); List<Integer> mapped = Functions.myFlatMap(numbers, t -> List.of(t - 1, t, t + 1)); assertEquals(Arrays.asList(3, 4, 5, 4, 5, 6, 6, 7, 8, 7, 8, 9), mapped); }
### Question: Functions { public static <T> void myForEach(List<T> list, MyConsumer<T> myConsumer) { for (T t : list) { myConsumer.accept(t); } } static List<T> myFilter(List<T> list, MyPredicate<T> myPredicate); static List<R> myMap(List<T> list, MyFunction<T, R> myFunction); static List<R> myFlatMap(List<T> list, MyFunction<T, List<R>> myFunction); static void myForEach(List<T> list, MyConsumer<T> myConsumer); static List<T> myGenerate(MySupplier<T> supplier, int count); }### Answer: @Test public void testMyForEach() { List<Integer> numbers = Arrays.asList(4, 5, 7, 8); Functions.myForEach(numbers, new MyConsumer<Integer>() { @Override public void accept(Integer x) { System.out.println(x); } }); }
### Question: WeChatUtils { public static String joinPath(final String firstPath, final String secondPath) { Validate.notEmpty(firstPath); Validate.notEmpty(secondPath); final String tmp1 = firstPath.endsWith("/") ? firstPath.substring(0, firstPath.length() - 1) : firstPath; final String tmp2 = secondPath.startsWith("/") ? (tmp1 + secondPath) : (tmp1 + "/" + secondPath); return tmp2.endsWith("/") ? tmp2.substring(0, tmp2.length() - 1) : tmp2; } private WeChatUtils(); @NotNull static String uuid32(); static String joinPath(final String firstPath, final String secondPath); static String urlEncode(final String urlStr); }### Answer: @Test public void joinPath() { assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: }
### Question: WeChatPayRestTemplateClient implements WeChatPayClient { @Override public UnifiedOrderResponse unifiedOrder( final UnifiedOrderRequest request) throws WeChatPayException { Objects.requireNonNull(request); return postForEntity( WeChatPayClient.UNIFIED_ORDER_PATH, request, UnifiedOrderResponse.class) .getBody(); } WeChatPayRestTemplateClient( final RestTemplate restTemplate, final WeChatPayProperties weChatPayProperties); @Override UnifiedOrderResponse unifiedOrder( final UnifiedOrderRequest request); @Override OrderQueryResponse orderQuery( final OrderQueryRequest request); @Override CloseOrderResponse closeOrder( final CloseOrderRequest request); @Override RefundResponse refund( final RefundRequest request); @Override RefundQueryResponse refundQuery( final RefundQueryRequest request); }### Answer: @Test public void unifiedOrder() { stubFor(post(urlEqualTo(WeChatPayClient.UNIFIED_ORDER_PATH)) .willReturn(aResponse() .withStatus(200) .withHeader("Content-Type", MediaType.APPLICATION_XML_VALUE) .withBody("<xml><return_code>SUCCESS</return_code><result_code>SUCCESS</result_code></xml>"))); WeChatPayConfigurator.DEFAULT.setMchKey("key"); final UnifiedOrderRequest request = UnifiedOrderRequest.createWithNative("body", "outTradeNo", 100); final UnifiedOrderResponse unifiedOrderResponse = this.weChatPayClient.unifiedOrder(request); assertThat(unifiedOrderResponse) .hasReturnCode("SUCCESS") .hasResultCode("SUCCESS"); }
### Question: WeChatPayRestTemplateClient implements WeChatPayClient { @Override public OrderQueryResponse orderQuery( final OrderQueryRequest request) throws WeChatPayException { Objects.requireNonNull(request); return postForEntity( WeChatPayClient.ORDER_QUERY_PATH, request, OrderQueryResponse.class) .getBody(); } WeChatPayRestTemplateClient( final RestTemplate restTemplate, final WeChatPayProperties weChatPayProperties); @Override UnifiedOrderResponse unifiedOrder( final UnifiedOrderRequest request); @Override OrderQueryResponse orderQuery( final OrderQueryRequest request); @Override CloseOrderResponse closeOrder( final CloseOrderRequest request); @Override RefundResponse refund( final RefundRequest request); @Override RefundQueryResponse refundQuery( final RefundQueryRequest request); }### Answer: @Test public void orderQuery() { }
### Question: WeChatMpController { @GetMapping(path = "${wechat.mp.authorize-code-path:" + WeChatMpProperties.AUTHORIZE_CODE_PATH + '}') public void authorizeCode( @RequestParam("code") final String code) { final WeChatMpAccessTokenResponse accessTokenResponse = this.weChatMpClient.accessToken(code); if (accessTokenResponse.isSuccessful()) { this.publisher.publishEvent(new WeChatMpAuthenticationSuccessEvent(accessTokenResponse)); } else { throw new WeChatMpAuthenticationException(String.format("errcode: %s, errmsg: %s", accessTokenResponse.getErrCode(), accessTokenResponse.getErrMsg())); } } WeChatMpController( @NotNull final WeChatMpProperties weChatMpProperties, @NotNull final WeChatMpClient weChatMpClient, @NotNull final ApplicationEventPublisher publisher); @GetMapping(path = "${wechat.mp.authorize-path:" + WeChatMpProperties.AUTHORIZE_PATH + "}") RedirectView authorize(@RequestParam("redirect") final String redirect); @GetMapping(path = "${wechat.mp.authorize-code-path:" + WeChatMpProperties.AUTHORIZE_CODE_PATH + '}') void authorizeCode( @RequestParam("code") final String code); }### Answer: @Test public void authorizeCode() throws Exception { final WeChatMpAccessTokenResponse accessTokenResponse = new WeChatMpAccessTokenResponse(); accessTokenResponse.setErrCode("0"); given(this.weChatMpClient.accessToken("code")).willReturn(accessTokenResponse); this.mvc.perform(get(WeChatMpProperties.AUTHORIZE_CODE_PATH) .param("code", "code") .accept(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()); }
### Question: WeChatMpAutoConfiguration { @Bean @ConditionalOnMissingBean public WeChatMpController weChatMpController(final WeChatMpClient weChatMpClient, final ApplicationEventPublisher publisher) { return new WeChatMpController(this.weChatMpProperties, weChatMpClient, publisher); } WeChatMpAutoConfiguration(final WeChatMpProperties weChatMpProperties); @Bean @ConditionalOnMissingBean WeChatMpController weChatMpController(final WeChatMpClient weChatMpClient, final ApplicationEventPublisher publisher); @Bean @ConditionalOnMissingBean WeChatMpClient weChatMpClient( @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection") @Autowired(required = false) final RestTemplateBuilder restTemplateBuilder); }### Answer: @Test public void weChatMpController() throws Exception { ClassPool.getDefault().makeClass("cn.javaer.wechat.spring.boot.starter.mp.ConditionalOnClassTrigger").toClass(); try (AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext()) { context.register(WeChatMpAutoConfiguration.class); context.refresh(); context.getBean(WeChatMpController.class); } }
### Question: WeChatMpResponse { @JsonAnySetter protected void setOtherProperties(final String name, final String value) { this.otherProperties.put(name, value); } boolean isSuccessful(); }### Answer: @Test public void setOtherProperties() throws Exception { final ObjectMapper mapper = new ObjectMapper(); final Demo demo = mapper.readValue("{\"errcode\":\"d1\",\"any1\":\"any1\",\"any2\":\"any2\"}", Demo.class); Assert.assertEquals("d1", demo.getErrCode()); Assert.assertEquals("any1", demo.getOtherProperties().get("any1")); Assert.assertEquals("any2", demo.getOtherProperties().get("any2")); }
### Question: WeChatMpUtils { public static String generateAuthorizeUrl( @NotNull final String appId, @NotNull final String redirectUri, @NotNull final AuthorizeScope scope, @NotNull final String state) { return "https: + "&redirect_uri=" + WeChatUtils.urlEncode(redirectUri) + "&response_type=code&scope=" + scope.getScope() + "&state=" + state + "#wechat_redirect"; } static String generateAuthorizeUrl( @NotNull final String appId, @NotNull final String redirectUri, @NotNull final AuthorizeScope scope, @NotNull final String state); static String generateAuthorizeUrl( @NotNull final String appId, @NotNull final String redirectUri, @NotNull final AuthorizeScope scope); static void checkResponseBody(final WeChatMpResponse response); }### Answer: @Test public void generateAuthorizeUrl() { final String authorizeUrl = WeChatMpUtils.generateAuthorizeUrl( "wx520c15f417810387", "https: AuthorizeScope.BASE, "123"); final String expected = "https: assertEquals(expected, authorizeUrl); } @Test public void generateAuthorizeUrlNoState() { final String authorizeUrl = WeChatMpUtils.generateAuthorizeUrl("wx520c15f417810387", "https: AuthorizeScope.BASE); final String expected = "https: assertEquals(expected, authorizeUrl); }
### Question: WeChatPayAutoConfiguration { @Bean @ConditionalOnMissingBean public WeChatPayClient weChatPayClient( @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection") @Autowired(required = false) RestTemplate restTemplate) { if (null == restTemplate) { restTemplate = new RestTemplate(); } return new WeChatPayRestTemplateClient(restTemplate, this.weChatPayProperties); } WeChatPayAutoConfiguration(final WeChatPayProperties weChatPayProperties); @Bean @ConditionalOnMissingBean WeChatPayClient weChatPayClient( @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection") @Autowired(required = false) RestTemplate restTemplate); @Bean @ConditionalOnMissingBean WeChatPayService weChatPayService( final WeChatPayClient weChatPayClient, final ApplicationEventPublisher publisher); @Bean @ConditionalOnMissingBean WeChatPayController weChatPayController(final ApplicationEventPublisher publisher); }### Answer: @Test public void weChatPayClient() throws Exception { ClassPool.getDefault().makeClass("cn.javaer.wechat.spring.boot.starter.pay.ConditionalOnClassTrigger").toClass(); try (AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext()) { context.register(WeChatPayAutoConfiguration.class); context.refresh(); context.getBean(WeChatPayClient.class); } }
### Question: BerOctetString implements Serializable, BerType { @Override public int encode(OutputStream reverseOS) throws IOException { return encode(reverseOS, true); } BerOctetString(); BerOctetString(byte[] value); @Override int encode(OutputStream reverseOS); int encode(OutputStream reverseOS, boolean withTag); @Override int decode(InputStream is); int decode(InputStream is, boolean withTag); @Override String toString(); static final BerTag tag; public byte[] value; }### Answer: @Test public void explicitEncoding() throws IOException { ReverseByteArrayOutputStream berStream = new ReverseByteArrayOutputStream(50); byte[] byteArray = new byte[] {0x01, 0x02, 0x03}; BerOctetString asn1OctetString = new BerOctetString(byteArray); int length = asn1OctetString.encode(berStream, true); assertEquals(5, length); byte[] expectedBytes = new byte[] {0x04, 0x03, 0x01, 0x02, 0x03}; assertArrayEquals(expectedBytes, berStream.getArray()); }
### Question: BerOctetString implements Serializable, BerType { @Override public int decode(InputStream is) throws IOException { return decode(is, true); } BerOctetString(); BerOctetString(byte[] value); @Override int encode(OutputStream reverseOS); int encode(OutputStream reverseOS, boolean withTag); @Override int decode(InputStream is); int decode(InputStream is, boolean withTag); @Override String toString(); static final BerTag tag; public byte[] value; }### Answer: @Test public void explicitDecoding() throws IOException { byte[] byteCode = new byte[] {0x04, 0x00}; ByteArrayInputStream berInputStream = new ByteArrayInputStream(byteCode); BerOctetString asn1OctetString = new BerOctetString(); asn1OctetString.decode(berInputStream, true); assertEquals(0, asn1OctetString.value.length); }
### Question: BerOctetString implements Serializable, BerType { @Override public String toString() { return HexString.fromBytes(value); } BerOctetString(); BerOctetString(byte[] value); @Override int encode(OutputStream reverseOS); int encode(OutputStream reverseOS, boolean withTag); @Override int decode(InputStream is); int decode(InputStream is, boolean withTag); @Override String toString(); static final BerTag tag; public byte[] value; }### Answer: @Test public void toStringTest() { BerOctetString octetString = new BerOctetString(new byte[] {1, 2, (byte) 0xa0}); assertEquals("0102A0", octetString.toString()); }
### Question: BerObjectIdentifier implements Serializable, BerType { @Override public int encode(OutputStream reverseOS) throws IOException { return encode(reverseOS, true); } BerObjectIdentifier(); BerObjectIdentifier(byte[] code); BerObjectIdentifier(int[] value); @Override int encode(OutputStream reverseOS); int encode(OutputStream reverseOS, boolean withTag); @Override int decode(InputStream is); int decode(InputStream is, boolean withTag); @Override String toString(); static final BerTag tag; public int[] value; }### Answer: @Test public void explicitEncoding() throws IOException { ReverseByteArrayOutputStream berBAOStream = new ReverseByteArrayOutputStream(50); BerObjectIdentifier oi = new BerObjectIdentifier(objectIdentifierComponents); int length = oi.encode(berBAOStream, true); assertEquals(7, length); assertArrayEquals(expectedBytes, berBAOStream.getArray()); }
### Question: BerObjectIdentifier implements Serializable, BerType { @Override public int decode(InputStream is) throws IOException { return decode(is, true); } BerObjectIdentifier(); BerObjectIdentifier(byte[] code); BerObjectIdentifier(int[] value); @Override int encode(OutputStream reverseOS); int encode(OutputStream reverseOS, boolean withTag); @Override int decode(InputStream is); int decode(InputStream is, boolean withTag); @Override String toString(); static final BerTag tag; public int[] value; }### Answer: @Test public void explicitDecoding() throws IOException { ByteArrayInputStream berInputStream = new ByteArrayInputStream(expectedBytes); BerObjectIdentifier oi = new BerObjectIdentifier(); oi.decode(berInputStream, true); assertArrayEquals(objectIdentifierComponents, oi.value); ByteArrayInputStream berInputStream2 = new ByteArrayInputStream(expectedBytes2); BerObjectIdentifier oi2 = new BerObjectIdentifier(); oi2.decode(berInputStream2, true); }
### Question: BerGeneralizedTime extends BerVisibleString { @Override public int encode(OutputStream reverseOS, boolean withTag) throws IOException { int codeLength = super.encode(reverseOS, false); if (withTag) { codeLength += tag.encode(reverseOS); } return codeLength; } BerGeneralizedTime(); BerGeneralizedTime(byte[] value); BerGeneralizedTime(String valueAsString); @Override int encode(OutputStream reverseOS, boolean withTag); @Override int decode(InputStream is, boolean withTag); Calendar asCalendar(); Date asDate(); static final BerTag tag; }### Answer: @Test public void explicitEncoding() throws IOException { ReverseByteArrayOutputStream berStream = new ReverseByteArrayOutputStream(50); byte[] byteArray = new byte[] {0x01, 0x02, 0x03}; BerGeneralizedTime berGeneralizedTime = new BerGeneralizedTime(byteArray); int length = berGeneralizedTime.encode(berStream, true); assertEquals(5, length); byte[] expectedBytes = new byte[] {24, 0x03, 0x01, 0x02, 0x03}; assertArrayEquals(expectedBytes, berStream.getArray()); }
### Question: BerBitString implements Serializable, BerType { @Override public String toString() { StringBuilder sb = new StringBuilder(); for (boolean bit : getValueAsBooleans()) { if (bit) { sb.append('1'); } else { sb.append('0'); } } return sb.toString(); } BerBitString(); BerBitString(byte[] value, int numBits); BerBitString(boolean[] value); BerBitString(byte[] code); boolean[] getValueAsBooleans(); @Override int encode(OutputStream reverseOS); int encode(OutputStream reverseOS, boolean withTag); @Override int decode(InputStream is); int decode(InputStream is, boolean withTag); @Override String toString(); static final BerTag tag; public byte[] value; public int numBits; }### Answer: @Test public void toStringTest() { BerBitString bitString = new BerBitString(new byte[] {1, 2, 7}, 23); assertEquals("00000001000000100000011", bitString.toString()); } @Test public void toString2Test() { BerBitString bitString = new BerBitString( new boolean[] { false, false, false, false, false, false, false, true, false, false, false, false, false, false, true, false, false, false, false, false, false, true, true }); assertEquals("00000001000000100000011", bitString.toString()); }
### Question: BerLength implements Serializable { public int decode(InputStream is) throws IOException { val = is.read(); if (val < 128) { if (val == -1) { throw new EOFException("Unexpected end of input stream."); } return 1; } int lengthLength = val & 0x7f; if (lengthLength == 0) { val = -1; return 1; } if (lengthLength > 4) { throw new IOException("Length is out of bounds: " + lengthLength); } val = 0; for (int i = 0; i < lengthLength; i++) { int nextByte = is.read(); if (nextByte == -1) { throw new EOFException("Unexpected end of input stream."); } val \|= nextByte << (8 * (lengthLength - i - 1)); } return lengthLength + 1; } BerLength(); static int encodeLength(OutputStream reverseOS, int length); static int readEocByte(InputStream is); int decode(InputStream is); int readEocIfIndefinite(InputStream is); public int val; }### Answer: @Test public void explicitDecoding() throws IOException { byte[] byteCode = new byte[] {(byte) 0x81, (byte) 128}; ByteArrayInputStream berInputStream = new ByteArrayInputStream(byteCode); BerLength berLength = new BerLength(); berLength.decode(berInputStream); assertEquals(128, berLength.val); }
### Question: PrimaryMetaStore extends AbstractMetaStore { @Override public FederationType getFederationType() { return FederationType.PRIMARY; } PrimaryMetaStore(); PrimaryMetaStore( String name, String remoteMetaStoreUris, AccessControlType accessControlType, String... writableDatabaseWhitelist); PrimaryMetaStore( String name, String remoteMetaStoreUris, AccessControlType accessControlType, List<String> writableDatabaseWhitelist); @Override FederationType getFederationType(); @NotNull @Override String getDatabasePrefix(); }### Answer: @Test public void testFederationType() { assertThat(metaStore.getFederationType(), is(FederationType.PRIMARY)); }
### Question: MetaStoreMappingDecorator implements MetaStoreMapping { @Override public String getMetastoreMappingName() { return metaStoreMapping.getMetastoreMappingName(); } MetaStoreMappingDecorator(MetaStoreMapping metaStoreMapping); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override void close(); @Override Iface getClient(); @Override String getDatabasePrefix(); @Override String getMetastoreMappingName(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override long getLatency(); }### Answer: @Test public void getMetastoreMappingName() throws Exception { when(metaStoreMapping.getMetastoreMappingName()).thenReturn("Name"); String result = decorator.getMetastoreMappingName(); assertThat(result, is("Name")); }
### Question: MetaStoreMappingDecorator implements MetaStoreMapping { @Override public boolean isAvailable() { return metaStoreMapping.isAvailable(); } MetaStoreMappingDecorator(MetaStoreMapping metaStoreMapping); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override void close(); @Override Iface getClient(); @Override String getDatabasePrefix(); @Override String getMetastoreMappingName(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override long getLatency(); }### Answer: @Test public void isAvailable() throws Exception { when(metaStoreMapping.isAvailable()).thenReturn(true); boolean result = decorator.isAvailable(); assertThat(result, is(true)); }
### Question: MetaStoreMappingDecorator implements MetaStoreMapping { @Override public String transformInboundDatabaseName(String databaseName) { return metaStoreMapping.transformInboundDatabaseName(databaseName); } MetaStoreMappingDecorator(MetaStoreMapping metaStoreMapping); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override void close(); @Override Iface getClient(); @Override String getDatabasePrefix(); @Override String getMetastoreMappingName(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override long getLatency(); }### Answer: @Test public void transformInboundDatabaseName() throws Exception { when(metaStoreMapping.transformInboundDatabaseName("db")).thenReturn("trans_db"); String result = decorator.transformInboundDatabaseName("db"); assertThat(result, is("trans_db")); }
### Question: MetaStoreMappingDecorator implements MetaStoreMapping { @Override public String transformOutboundDatabaseName(String databaseName) { return metaStoreMapping.transformOutboundDatabaseName(databaseName); } MetaStoreMappingDecorator(MetaStoreMapping metaStoreMapping); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override void close(); @Override Iface getClient(); @Override String getDatabasePrefix(); @Override String getMetastoreMappingName(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override long getLatency(); }### Answer: @Test public void transformOutboundDatabaseName() throws Exception { when(metaStoreMapping.transformOutboundDatabaseName("db")).thenReturn("trans_db"); String result = decorator.transformOutboundDatabaseName("db"); assertThat(result, is("trans_db")); }
### Question: MetaStoreMappingDecorator implements MetaStoreMapping { @Override public Database transformOutboundDatabase(Database database) { return metaStoreMapping.transformOutboundDatabase(database); } MetaStoreMappingDecorator(MetaStoreMapping metaStoreMapping); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override void close(); @Override Iface getClient(); @Override String getDatabasePrefix(); @Override String getMetastoreMappingName(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override long getLatency(); }### Answer: @Test public void transformOutboundDatabase() throws Exception { Database database = new Database(); database.setName("a"); Database expected = new Database(); expected.setName("b"); when(metaStoreMapping.transformOutboundDatabase(database)).thenReturn(expected); Database result = decorator.transformOutboundDatabase(database); assertThat(result, is(expected)); }
### Question: MetaStoreMappingImpl implements MetaStoreMapping { @Override public String transformOutboundDatabaseName(String databaseName) { return databaseName.toLowerCase(Locale.ROOT); } MetaStoreMappingImpl( String databasePrefix, String name, CloseableThriftHiveMetastoreIface client, AccessControlHandler accessControlHandler, ConnectionType connectionType, long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer: @Test public void transformOutboundDatabaseName() { assertThat(metaStoreMapping.transformOutboundDatabaseName("My_Database"), is("my_database")); }
### Question: MetaStoreMappingImpl implements MetaStoreMapping { @Override public Database transformOutboundDatabase(Database database) { database.setName(transformOutboundDatabaseName(database.getName())); return database; } MetaStoreMappingImpl( String databasePrefix, String name, CloseableThriftHiveMetastoreIface client, AccessControlHandler accessControlHandler, ConnectionType connectionType, long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer: @Test public void transformOutboundDatabase() { when(database.getName()).thenReturn("My_Database"); Database outboundDatabase = metaStoreMapping.transformOutboundDatabase(database); assertThat(outboundDatabase, is(sameInstance(database))); verify(outboundDatabase).setName("my_database"); }
### Question: MetaStoreMappingImpl implements MetaStoreMapping { @Override public String transformInboundDatabaseName(String databaseName) { return databaseName.toLowerCase(Locale.ROOT); } MetaStoreMappingImpl( String databasePrefix, String name, CloseableThriftHiveMetastoreIface client, AccessControlHandler accessControlHandler, ConnectionType connectionType, long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer: @Test public void transformInboundDatabaseName() { assertThat(metaStoreMapping.transformInboundDatabaseName("My_Database"), is("my_database")); } @Test public void transformInboundDatabaseNameWithoutPrefixReturnsDatabase() { assertThat(metaStoreMapping.transformInboundDatabaseName("no_prefix_My_Database"), is("no_prefix_my_database")); }
### Question: MetaStoreMappingImpl implements MetaStoreMapping { @Override public String getDatabasePrefix() { return databasePrefix; } MetaStoreMappingImpl( String databasePrefix, String name, CloseableThriftHiveMetastoreIface client, AccessControlHandler accessControlHandler, ConnectionType connectionType, long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer: @Test public void getDatabasePrefix() { assertThat(metaStoreMapping.getDatabasePrefix(), is(DATABASE_PREFIX)); }
### Question: MetaStoreMappingImpl implements MetaStoreMapping { @Override public String getMetastoreMappingName() { return name; } MetaStoreMappingImpl( String databasePrefix, String name, CloseableThriftHiveMetastoreIface client, AccessControlHandler accessControlHandler, ConnectionType connectionType, long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer: @Test public void getMetastoreMappingNameSameAsPrefix() { assertThat(metaStoreMapping.getMetastoreMappingName(), is(NAME)); }
### Question: MetaStoreMappingImpl implements MetaStoreMapping { @Override public void close() throws IOException { client.close(); } MetaStoreMappingImpl( String databasePrefix, String name, CloseableThriftHiveMetastoreIface client, AccessControlHandler accessControlHandler, ConnectionType connectionType, long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer: @Test public void close() throws IOException { metaStoreMapping.close(); verify(client).close(); }
### Question: MetaStoreMappingImpl implements MetaStoreMapping { @Override public boolean isAvailable() { try { boolean isOpen = client.isOpen(); if (isOpen && connectionType == ConnectionType.TUNNELED) { client.getStatus(); } return isOpen; } catch (Exception e) { log.error("Metastore Mapping {} unavailable", name, e); return false; } } MetaStoreMappingImpl( String databasePrefix, String name, CloseableThriftHiveMetastoreIface client, AccessControlHandler accessControlHandler, ConnectionType connectionType, long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer: @Test public void isAvailable() { when(client.isOpen()).thenReturn(true); assertThat(metaStoreMapping.isAvailable(), is(true)); } @Test public void isNotAvailable() { when(client.isOpen()).thenReturn(false); assertThat(metaStoreMapping.isAvailable(), is(false)); } @Test public void isAvailableTunnelled() throws Exception { when(client.isOpen()).thenReturn(true); assertThat(tunneledMetaStoreMapping.isAvailable(), is(true)); verify(client).getStatus(); } @Test public void isNotAvailableTunnelled() throws Exception { when(client.isOpen()).thenReturn(false); assertThat(tunneledMetaStoreMapping.isAvailable(), is(false)); verify(client, never()).getStatus(); } @Test public void isNotAvailableClientErrorTunnelled() throws Exception { when(client.isOpen()).thenReturn(true); when(client.getStatus()).thenThrow(new TException("ERROR")); assertThat(tunneledMetaStoreMapping.isAvailable(), is(false)); }
### Question: MetaStoreMappingImpl implements MetaStoreMapping { @Override public MetaStoreMapping checkWritePermissions(String databaseName) { if (!accessControlHandler.hasWritePermission(databaseName)) { throw new NotAllowedException( "You cannot perform this operation on the virtual database '" + databaseName + "'."); } return this; } MetaStoreMappingImpl( String databasePrefix, String name, CloseableThriftHiveMetastoreIface client, AccessControlHandler accessControlHandler, ConnectionType connectionType, long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer: @Test public void checkWritePermissions() { String databaseName = "db"; when(accessControlHandler.hasWritePermission(databaseName)).thenReturn(true); assertThat(metaStoreMapping.checkWritePermissions(databaseName), is(metaStoreMapping)); } @Test(expected = NotAllowedException.class) public void checkWritePermissionsThrowsException() { String databaseName = "db"; when(accessControlHandler.hasWritePermission(databaseName)).thenReturn(false); metaStoreMapping.checkWritePermissions(databaseName); }
### Question: MetaStoreMappingImpl implements MetaStoreMapping { @Override public void createDatabase(Database database) throws AlreadyExistsException, InvalidObjectException, MetaException, TException { if (accessControlHandler.hasCreatePermission()) { getClient().create_database(database); accessControlHandler.databaseCreatedNotification(database.getName()); } else { throw new NotAllowedException("You cannot create the database '" + database.getName() + "'."); } } MetaStoreMappingImpl( String databasePrefix, String name, CloseableThriftHiveMetastoreIface client, AccessControlHandler accessControlHandler, ConnectionType connectionType, long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer: @Test public void createDatabase() throws Exception { when(database.getName()).thenReturn("db"); when(accessControlHandler.hasCreatePermission()).thenReturn(true); metaStoreMapping.createDatabase(database); verify(client).create_database(database); verify(accessControlHandler).databaseCreatedNotification("db"); } @Test public void createDatabasePermissionDenied() throws Exception { when(database.getName()).thenReturn("db"); when(accessControlHandler.hasCreatePermission()).thenReturn(false); try { metaStoreMapping.createDatabase(database); fail("Should have thrown exception"); } catch (NotAllowedException e) { verify(client, never()).create_database(database); verify(accessControlHandler, never()).databaseCreatedNotification("db"); } }
### Question: MetaStoreMappingImpl implements MetaStoreMapping { @Override public long getLatency() { return latency; } MetaStoreMappingImpl( String databasePrefix, String name, CloseableThriftHiveMetastoreIface client, AccessControlHandler accessControlHandler, ConnectionType connectionType, long latency); @Override String transformOutboundDatabaseName(String databaseName); @Override List<String> transformOutboundDatabaseNameMultiple(String databaseName); @Override ThriftHiveMetastore.Iface getClient(); @Override Database transformOutboundDatabase(Database database); @Override String transformInboundDatabaseName(String databaseName); @Override String getDatabasePrefix(); @Override void close(); @Override boolean isAvailable(); @Override MetaStoreMapping checkWritePermissions(String databaseName); @Override void createDatabase(Database database); @Override String getMetastoreMappingName(); @Override long getLatency(); }### Answer: @Test public void getLatency() { assertThat(metaStoreMapping.getLatency(), is(LATENCY)); }
### Question: FederatedMetaStore extends AbstractMetaStore { @Override public FederationType getFederationType() { return FederationType.FEDERATED; } FederatedMetaStore(); FederatedMetaStore(String name, String remoteMetaStoreUris); FederatedMetaStore(String name, String remoteMetaStoreUris, AccessControlType accessControlType); FederatedMetaStore(FederatedMetaStore federatedMetaStore); FederatedMetaStore( String name, String remoteMetaStoreUris, AccessControlType accessControlType, List<String> writableDatabaseWhiteList); @Override FederationType getFederationType(); @Override String getDatabasePrefix(); }### Answer: @Test public void testFederationType() { assertThat(metaStore.getFederationType(), is(FederationType.FEDERATED)); }
### Question: FederatedMetaStore extends AbstractMetaStore { @Override public String getDatabasePrefix() { String prefix = super.getDatabasePrefix(); if (prefix == null) { prefix = getName() + "_"; } return prefix; } FederatedMetaStore(); FederatedMetaStore(String name, String remoteMetaStoreUris); FederatedMetaStore(String name, String remoteMetaStoreUris, AccessControlType accessControlType); FederatedMetaStore(FederatedMetaStore federatedMetaStore); FederatedMetaStore( String name, String remoteMetaStoreUris, AccessControlType accessControlType, List<String> writableDatabaseWhiteList); @Override FederationType getFederationType(); @Override String getDatabasePrefix(); }### Answer: @Test public void emptyDatabasePrefix() { metaStore.setDatabasePrefix(""); Set<ConstraintViolation<FederatedMetaStore>> violations = validator.validate(metaStore); assertThat(violations.size(), is(0)); assertThat(metaStore.getDatabasePrefix(), is("")); } @Test public void nonEmptyDatabasePrefix() { metaStore.setDatabasePrefix("override"); Set<ConstraintViolation<FederatedMetaStore>> violations = validator.validate(metaStore); assertThat(violations.size(), is(0)); assertThat("override", is(metaStore.getDatabasePrefix())); } @Test public void nullDatabasePrefix() { metaStore.setDatabasePrefix(null); Set<ConstraintViolation<FederatedMetaStore>> violations = validator.validate(metaStore); assertThat(violations.size(), is(0)); assertThat("name_", is(metaStore.getDatabasePrefix())); }
### Question: ValidationError { public void addValidationError(String error) { errors.add(error); } private ValidationError(String errorMessage); static ValidationErrorBuilder builder(); static ValidationErrorBuilder builder(Errors errors); void addValidationError(String error); List<String> getErrors(); String getErrorMessage(); }### Answer: @Test public void addValidationError() { String errorMessage = "Another error"; ValidationError validationError = ValidationError.builder().build(); validationError.addValidationError(errorMessage); List<String> expectedErrors = Collections.singletonList(errorMessage); assertThat(validationError.getErrorMessage(), is("Validation failed")); assertThat(validationError.getErrors(), is(expectedErrors)); }
### Question: FederationsAdminController { @RequestMapping(method = RequestMethod.POST) public void add(@Validated @RequestBody AbstractMetaStore federatedMetaStore) { federationService.register(federatedMetaStore); } @Autowired FederationsAdminController(@Qualifier("populateStatusFederationService") FederationService federationService); @RequestMapping(method = RequestMethod.GET) @ResponseBody List<AbstractMetaStore> federations(); @RequestMapping(method = RequestMethod.GET, path = "/{name}") @ResponseBody AbstractMetaStore read(@NotNull @PathVariable String name); @RequestMapping(method = RequestMethod.POST) void add(@Validated @RequestBody AbstractMetaStore federatedMetaStore); @RequestMapping(method = RequestMethod.DELETE, path = "/{name}") void remove(@NotNull @PathVariable String name); @ExceptionHandler(ValidationException.class) @ResponseStatus(value = HttpStatus.BAD_REQUEST) ValidationError handleValidationException(HttpServletRequest req, ValidationException exception); @ExceptionHandler(MethodArgumentNotValidException.class) @ResponseStatus(value = HttpStatus.BAD_REQUEST) ValidationError handleException(HttpServletRequest req, MethodArgumentNotValidException exception); }### Answer: @Test public void add() throws Exception { String content = Jackson2ObjectMapperBuilder.json().build().writeValueAsString(metastore); mockMvc .perform(post("/api/admin/federations/").contentType(MediaType.APPLICATION_JSON_UTF8).content(content)) .andExpect(status().isOk()); verify(populateStatusFederationService).register(metastore); }
### Question: PrimaryMetaStore extends AbstractMetaStore { @NotNull @Override public String getDatabasePrefix() { String prefix = super.getDatabasePrefix(); if (prefix == null) { prefix = EMPTY_PREFIX; } return prefix; } PrimaryMetaStore(); PrimaryMetaStore( String name, String remoteMetaStoreUris, AccessControlType accessControlType, String... writableDatabaseWhitelist); PrimaryMetaStore( String name, String remoteMetaStoreUris, AccessControlType accessControlType, List<String> writableDatabaseWhitelist); @Override FederationType getFederationType(); @NotNull @Override String getDatabasePrefix(); }### Answer: @Test public void emptyDatabasePrefix() { metaStore.setDatabasePrefix(""); Set<ConstraintViolation<PrimaryMetaStore>> violations = validator.validate(metaStore); assertThat(violations.size(), is(0)); assertThat(metaStore.getDatabasePrefix(), is("")); } @Test public void nullDatabasePrefix() { metaStore.setDatabasePrefix(null); Set<ConstraintViolation<PrimaryMetaStore>> violations = validator.validate(metaStore); assertThat(violations.size(), is(0)); assertThat(metaStore.getDatabasePrefix(), is("")); } @Test public void nonEmptyDatabasePrefix() { String prefix = "abc"; metaStore.setDatabasePrefix(prefix); Set<ConstraintViolation<PrimaryMetaStore>> violations = validator.validate(metaStore); assertThat(violations.size(), is(0)); assertThat(metaStore.getDatabasePrefix(), is(prefix)); }
### Question: StaticDatabaseMappingService implements MappingEventListener { @Override public DatabaseMapping databaseMapping(@NotNull String databaseName) throws NoSuchObjectException { DatabaseMapping databaseMapping = mappingsByDatabaseName.get(databaseName.toLowerCase(Locale.ROOT)); if (databaseMapping != null) { LOG .debug("Database Name `{}` maps to metastore with name '{}'", databaseName, databaseMapping.getMetastoreMappingName()); if (includeInResults(databaseMapping)) { return databaseMapping; } } LOG.debug("Database Name `{}` not mapped", databaseName); throw new NoSuchObjectException("Primary metastore does not have database " + databaseName); } StaticDatabaseMappingService( MetaStoreMappingFactory metaStoreMappingFactory, List<AbstractMetaStore> initialMetastores, QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer: @Test public void databaseMappingPrimary() throws NoSuchObjectException { DatabaseMapping databaseMapping = service.databaseMapping(PRIMARY_DB); assertThat(databaseMapping.getMetastoreMappingName(), is(PRIMARY_NAME)); assertTrue(databaseMapping instanceof DatabaseMappingImpl); } @Test(expected = NoSuchObjectException.class) public void databaseMappingPrimaryNotMatching() throws NoSuchObjectException { service.databaseMapping("some_unknown_non_federated_db"); } @Test public void databaseMappingFederated() throws NoSuchObjectException { service.databaseMapping(FEDERATED_DB); DatabaseMapping databaseMapping = service.databaseMapping(FEDERATED_DB); assertThat(databaseMapping.getMetastoreMappingName(), is(FEDERATED_NAME)); assertTrue(databaseMapping instanceof DatabaseMappingImpl); }
### Question: StaticDatabaseMappingService implements MappingEventListener { @Override public void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore) { synchronized (mappingsByMetaStoreName) { remove(oldMetaStore); add(newMetaStore); } } StaticDatabaseMappingService( MetaStoreMappingFactory metaStoreMappingFactory, List<AbstractMetaStore> initialMetastores, QueryMapping queryMapping); @Override void onRegister(AbstractMetaStore metaStore); @Override void onUpdate(AbstractMetaStore oldMetaStore, AbstractMetaStore newMetaStore); @Override void onUnregister(AbstractMetaStore metaStore); @Override DatabaseMapping primaryDatabaseMapping(); @Override DatabaseMapping databaseMapping(@NotNull String databaseName); @Override List<DatabaseMapping> getDatabaseMappings(); @Override PanopticOperationHandler getPanopticOperationHandler(); @Override void close(); }### Answer: @Test public void onUpdate() throws TException { FederatedMetaStore newMetastore = newFederatedInstanceWithClient(FEDERATED_NAME, "abc", Lists.newArrayList("db1", "federated_DB"), true); service.onUpdate(federatedMetastore, newMetastore); DatabaseMapping databaseMapping = service.databaseMapping("db1"); assertThat(databaseMapping.getMetastoreMappingName(), is(FEDERATED_NAME)); assertTrue(databaseMapping instanceof DatabaseMappingImpl); databaseMapping = service.databaseMapping(FEDERATED_DB); assertThat(databaseMapping.getMetastoreMappingName(), is(FEDERATED_NAME)); assertTrue(databaseMapping instanceof DatabaseMappingImpl); }

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.