Datasets:
Minata
/
1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files
xet
Community
1
method2testcases
stringlengths
118
6.63k
### Question: ByteUtils { public static byte[] shortToBytesBE(int i, byte[] bytes, int off) { bytes[off] = (byte) (i >> 8); bytes[off + 1] = (byte) i; return bytes; } static int bytesToVR(byte[] bytes, int off); static int bytesToUShort(byte[] bytes, int off, boolean bigEndian); static int bytesToUShortBE(byte[] bytes, int off); static int bytesToUShortLE(byte[] bytes, int off); static int bytesToShort(byte[] bytes, int off, boolean bigEndian); static int bytesToShortBE(byte[] bytes, int off); static int bytesToShortLE(byte[] bytes, int off); static void bytesToShorts(byte[] b, short[] s, int off, int len, boolean bigEndian); static void bytesToShortsLE(byte[] b, short[] s, int off, int len); static void bytesToShortsBE(byte[] b, short[] s, int off, int len); static int bytesToInt(byte[] bytes, int off, boolean bigEndian); static int bytesToIntBE(byte[] bytes, int off); static int bytesToIntLE(byte[] bytes, int off); static int bytesToTag(byte[] bytes, int off, boolean bigEndian); static int bytesToTagBE(byte[] bytes, int off); static int bytesToTagLE(byte[] bytes, int off); static float bytesToFloat(byte[] bytes, int off, boolean bigEndian); static float bytesToFloatBE(byte[] bytes, int off); static float bytesToFloatLE(byte[] bytes, int off); static long bytesToLong(byte[] bytes, int off, boolean bigEndian); static long bytesToLongBE(byte[] bytes, int off); static long bytesToLongLE(byte[] bytes, int off); static double bytesToDouble(byte[] bytes, int off, boolean bigEndian); static double bytesToDoubleBE(byte[] bytes, int off); static double bytesToDoubleLE(byte[] bytes, int off); static byte[] shortToBytes(int i, byte[] bytes, int off, boolean bigEndian); static byte[] shortToBytesBE(int i, byte[] bytes, int off); static byte[] shortToBytesLE(int i, byte[] bytes, int off); static byte[] intToBytes(int i, byte[] bytes, int off, boolean bigEndian); static byte[] intToBytesBE(int i, byte[] bytes, int off); static byte[] intToBytesLE(int i, byte[] bytes, int off); static byte[] tagToBytes(int i, byte[] bytes, int off, boolean bigEndian); static byte[] tagToBytesBE(int i, byte[] bytes, int off); static byte[] tagToBytesLE(int i, byte[] bytes, int off); static byte[] floatToBytes(float f, byte[] bytes, int off, boolean bigEndian); static byte[] floatToBytesBE(float f, byte[] bytes, int off); static byte[] floatToBytesLE(float f, byte[] bytes, int off); static byte[] doubleToBytes(double d, byte[] bytes, int off, boolean bigEndian); static byte[] doubleToBytesBE(double d, byte[] bytes, int off); static byte[] doubleToBytesLE(double d, byte[] bytes, int off); static byte[] longToBytes(long l, byte[] bytes, int off, boolean bigEndian); static byte[] longToBytesBE(long l, byte[] bytes, int off); static byte[] longToBytesLE(long l, byte[] bytes, int off); static byte[][] swapShorts(byte bs[][]); static byte[] swapShorts(byte b[], int off, int len); static byte[] swapInts(byte b[], int off, int len); static byte[] swapLongs(byte b[], int off, int len); static byte[] intsToBytesLE(int... values); static final byte[] EMPTY_BYTES; static final int[] EMPTY_INTS; static final float[] EMPTY_FLOATS; static final double[] EMPTY_DOUBLES; }### Answer: @Test public void testShortToBytesBE() { assertArrayEquals(SHORT_12345_BE, ByteUtils.shortToBytesBE(-12345, new byte[2] , 0)); }
### Question: ByteUtils { public static byte[] shortToBytesLE(int i, byte[] bytes, int off) { bytes[off + 1] = (byte) (i >> 8); bytes[off] = (byte) i; return bytes; } static int bytesToVR(byte[] bytes, int off); static int bytesToUShort(byte[] bytes, int off, boolean bigEndian); static int bytesToUShortBE(byte[] bytes, int off); static int bytesToUShortLE(byte[] bytes, int off); static int bytesToShort(byte[] bytes, int off, boolean bigEndian); static int bytesToShortBE(byte[] bytes, int off); static int bytesToShortLE(byte[] bytes, int off); static void bytesToShorts(byte[] b, short[] s, int off, int len, boolean bigEndian); static void bytesToShortsLE(byte[] b, short[] s, int off, int len); static void bytesToShortsBE(byte[] b, short[] s, int off, int len); static int bytesToInt(byte[] bytes, int off, boolean bigEndian); static int bytesToIntBE(byte[] bytes, int off); static int bytesToIntLE(byte[] bytes, int off); static int bytesToTag(byte[] bytes, int off, boolean bigEndian); static int bytesToTagBE(byte[] bytes, int off); static int bytesToTagLE(byte[] bytes, int off); static float bytesToFloat(byte[] bytes, int off, boolean bigEndian); static float bytesToFloatBE(byte[] bytes, int off); static float bytesToFloatLE(byte[] bytes, int off); static long bytesToLong(byte[] bytes, int off, boolean bigEndian); static long bytesToLongBE(byte[] bytes, int off); static long bytesToLongLE(byte[] bytes, int off); static double bytesToDouble(byte[] bytes, int off, boolean bigEndian); static double bytesToDoubleBE(byte[] bytes, int off); static double bytesToDoubleLE(byte[] bytes, int off); static byte[] shortToBytes(int i, byte[] bytes, int off, boolean bigEndian); static byte[] shortToBytesBE(int i, byte[] bytes, int off); static byte[] shortToBytesLE(int i, byte[] bytes, int off); static byte[] intToBytes(int i, byte[] bytes, int off, boolean bigEndian); static byte[] intToBytesBE(int i, byte[] bytes, int off); static byte[] intToBytesLE(int i, byte[] bytes, int off); static byte[] tagToBytes(int i, byte[] bytes, int off, boolean bigEndian); static byte[] tagToBytesBE(int i, byte[] bytes, int off); static byte[] tagToBytesLE(int i, byte[] bytes, int off); static byte[] floatToBytes(float f, byte[] bytes, int off, boolean bigEndian); static byte[] floatToBytesBE(float f, byte[] bytes, int off); static byte[] floatToBytesLE(float f, byte[] bytes, int off); static byte[] doubleToBytes(double d, byte[] bytes, int off, boolean bigEndian); static byte[] doubleToBytesBE(double d, byte[] bytes, int off); static byte[] doubleToBytesLE(double d, byte[] bytes, int off); static byte[] longToBytes(long l, byte[] bytes, int off, boolean bigEndian); static byte[] longToBytesBE(long l, byte[] bytes, int off); static byte[] longToBytesLE(long l, byte[] bytes, int off); static byte[][] swapShorts(byte bs[][]); static byte[] swapShorts(byte b[], int off, int len); static byte[] swapInts(byte b[], int off, int len); static byte[] swapLongs(byte b[], int off, int len); static byte[] intsToBytesLE(int... values); static final byte[] EMPTY_BYTES; static final int[] EMPTY_INTS; static final float[] EMPTY_FLOATS; static final double[] EMPTY_DOUBLES; }### Answer: @Test public void testShortToBytesLE() { assertArrayEquals(SHORT_12345_LE, ByteUtils.shortToBytesLE(-12345, new byte[2] , 0)); }
### Question: ByteUtils { public static byte[] tagToBytesBE(int i, byte[] bytes, int off) { return intToBytesBE(i, bytes, off); } static int bytesToVR(byte[] bytes, int off); static int bytesToUShort(byte[] bytes, int off, boolean bigEndian); static int bytesToUShortBE(byte[] bytes, int off); static int bytesToUShortLE(byte[] bytes, int off); static int bytesToShort(byte[] bytes, int off, boolean bigEndian); static int bytesToShortBE(byte[] bytes, int off); static int bytesToShortLE(byte[] bytes, int off); static void bytesToShorts(byte[] b, short[] s, int off, int len, boolean bigEndian); static void bytesToShortsLE(byte[] b, short[] s, int off, int len); static void bytesToShortsBE(byte[] b, short[] s, int off, int len); static int bytesToInt(byte[] bytes, int off, boolean bigEndian); static int bytesToIntBE(byte[] bytes, int off); static int bytesToIntLE(byte[] bytes, int off); static int bytesToTag(byte[] bytes, int off, boolean bigEndian); static int bytesToTagBE(byte[] bytes, int off); static int bytesToTagLE(byte[] bytes, int off); static float bytesToFloat(byte[] bytes, int off, boolean bigEndian); static float bytesToFloatBE(byte[] bytes, int off); static float bytesToFloatLE(byte[] bytes, int off); static long bytesToLong(byte[] bytes, int off, boolean bigEndian); static long bytesToLongBE(byte[] bytes, int off); static long bytesToLongLE(byte[] bytes, int off); static double bytesToDouble(byte[] bytes, int off, boolean bigEndian); static double bytesToDoubleBE(byte[] bytes, int off); static double bytesToDoubleLE(byte[] bytes, int off); static byte[] shortToBytes(int i, byte[] bytes, int off, boolean bigEndian); static byte[] shortToBytesBE(int i, byte[] bytes, int off); static byte[] shortToBytesLE(int i, byte[] bytes, int off); static byte[] intToBytes(int i, byte[] bytes, int off, boolean bigEndian); static byte[] intToBytesBE(int i, byte[] bytes, int off); static byte[] intToBytesLE(int i, byte[] bytes, int off); static byte[] tagToBytes(int i, byte[] bytes, int off, boolean bigEndian); static byte[] tagToBytesBE(int i, byte[] bytes, int off); static byte[] tagToBytesLE(int i, byte[] bytes, int off); static byte[] floatToBytes(float f, byte[] bytes, int off, boolean bigEndian); static byte[] floatToBytesBE(float f, byte[] bytes, int off); static byte[] floatToBytesLE(float f, byte[] bytes, int off); static byte[] doubleToBytes(double d, byte[] bytes, int off, boolean bigEndian); static byte[] doubleToBytesBE(double d, byte[] bytes, int off); static byte[] doubleToBytesLE(double d, byte[] bytes, int off); static byte[] longToBytes(long l, byte[] bytes, int off, boolean bigEndian); static byte[] longToBytesBE(long l, byte[] bytes, int off); static byte[] longToBytesLE(long l, byte[] bytes, int off); static byte[][] swapShorts(byte bs[][]); static byte[] swapShorts(byte b[], int off, int len); static byte[] swapInts(byte b[], int off, int len); static byte[] swapLongs(byte b[], int off, int len); static byte[] intsToBytesLE(int... values); static final byte[] EMPTY_BYTES; static final int[] EMPTY_INTS; static final float[] EMPTY_FLOATS; static final double[] EMPTY_DOUBLES; }### Answer: @Test public void testTagToBytesBE() { assertArrayEquals(TAG_PIXEL_DATA_BE, ByteUtils.tagToBytesBE(Tag.PixelData, new byte[4] , 0)); }
### Question: AttributeSelector implements Serializable { public static AttributeSelector valueOf(String s) { int fromIndex = s.lastIndexOf("DicomAttribute"); try { return new AttributeSelector( selectTag(s, fromIndex), selectPrivateCreator(s, fromIndex), itemPointersOf(s, fromIndex)); } catch (Exception e) { throw new IllegalArgumentException(s); } } AttributeSelector(int tag); AttributeSelector(int tag, String privateCreator); AttributeSelector(int tag, String privateCreator, ItemPointer... itemPointers); AttributeSelector(int tag, String privateCreator, List<ItemPointer> itemPointers); int tag(); String privateCreator(); int level(); ItemPointer itemPointer(int index); String selectStringValue(Attributes attrs, int valueIndex, String defVal); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); static AttributeSelector valueOf(String s); boolean matches(List<ItemPointer> itemPointers, String privateCreator, int tag); }### Answer: @Test public void testValueOf() { AttributeSelector selector = AttributeSelector.valueOf(XPATH); assertEquals(Tag.StudyInstanceUID, selector.tag()); assertNull(selector.privateCreator()); assertEquals(1, selector.level()); ItemPointer ip = selector.itemPointer(0); assertEquals(Tag.RequestAttributesSequence, ip.sequenceTag); assertNull(ip.privateCreator); assertEquals(-1, ip.itemIndex); }
### Question: WebConfigurer implements ServletContextInitializer, EmbeddedServletContainerCustomizer { @Override public void onStartup(ServletContext servletContext) throws ServletException { if (env.getActiveProfiles().length != 0) { log.info("Web application configuration, using profiles: {}", (Object[]) env.getActiveProfiles()); } EnumSet<DispatcherType> disps = EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.ASYNC); initMetrics(servletContext, disps); if (env.acceptsProfiles(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT)) { initH2Console(servletContext); } log.info("Web application fully configured"); } WebConfigurer(Environment env, JHipsterProperties jHipsterProperties, HazelcastInstance hazelcastInstance); @Override void onStartup(ServletContext servletContext); @Override void customize(ConfigurableEmbeddedServletContainer container); @Bean CorsFilter corsFilter(); @Autowired(required = false) void setMetricRegistry(MetricRegistry metricRegistry); }### Answer: @Test public void testStartUpProdServletContext() throws ServletException { env.setActiveProfiles(JHipsterConstants.SPRING_PROFILE_PRODUCTION); webConfigurer.onStartup(servletContext); assertThat(servletContext.getAttribute(InstrumentedFilter.REGISTRY_ATTRIBUTE)).isEqualTo(metricRegistry); assertThat(servletContext.getAttribute(MetricsServlet.METRICS_REGISTRY)).isEqualTo(metricRegistry); verify(servletContext).addFilter(eq("webappMetricsFilter"), any(InstrumentedFilter.class)); verify(servletContext).addServlet(eq("metricsServlet"), any(MetricsServlet.class)); verify(servletContext, never()).addServlet(eq("H2Console"), any(WebServlet.class)); } @Test public void testStartUpDevServletContext() throws ServletException { env.setActiveProfiles(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT); webConfigurer.onStartup(servletContext); assertThat(servletContext.getAttribute(InstrumentedFilter.REGISTRY_ATTRIBUTE)).isEqualTo(metricRegistry); assertThat(servletContext.getAttribute(MetricsServlet.METRICS_REGISTRY)).isEqualTo(metricRegistry); verify(servletContext).addFilter(eq("webappMetricsFilter"), any(InstrumentedFilter.class)); verify(servletContext).addServlet(eq("metricsServlet"), any(MetricsServlet.class)); verify(servletContext).addServlet(eq("H2Console"), any(WebServlet.class)); }
### Question: WebConfigurer implements ServletContextInitializer, EmbeddedServletContainerCustomizer { @Override public void customize(ConfigurableEmbeddedServletContainer container) { MimeMappings mappings = new MimeMappings(MimeMappings.DEFAULT); mappings.add("html", "text/html;charset=utf-8"); mappings.add("json", "text/html;charset=utf-8"); container.setMimeMappings(mappings); if (jHipsterProperties.getHttp().getVersion().equals(JHipsterProperties.Http.Version.V_2_0) && container instanceof UndertowEmbeddedServletContainerFactory) { ((UndertowEmbeddedServletContainerFactory) container) .addBuilderCustomizers(builder -> builder.setServerOption(UndertowOptions.ENABLE_HTTP2, true)); } } WebConfigurer(Environment env, JHipsterProperties jHipsterProperties, HazelcastInstance hazelcastInstance); @Override void onStartup(ServletContext servletContext); @Override void customize(ConfigurableEmbeddedServletContainer container); @Bean CorsFilter corsFilter(); @Autowired(required = false) void setMetricRegistry(MetricRegistry metricRegistry); }### Answer: @Test public void testCustomizeServletContainer() { env.setActiveProfiles(JHipsterConstants.SPRING_PROFILE_PRODUCTION); UndertowEmbeddedServletContainerFactory container = new UndertowEmbeddedServletContainerFactory(); webConfigurer.customize(container); assertThat(container.getMimeMappings().get("abs")).isEqualTo("audio/x-mpeg"); assertThat(container.getMimeMappings().get("html")).isEqualTo("text/html;charset=utf-8"); assertThat(container.getMimeMappings().get("json")).isEqualTo("text/html;charset=utf-8"); Builder builder = Undertow.builder(); container.getBuilderCustomizers().forEach(c -> c.customize(builder)); OptionMap.Builder serverOptions = (OptionMap.Builder) ReflectionTestUtils.getField(builder, "serverOptions"); assertThat(serverOptions.getMap().get(UndertowOptions.ENABLE_HTTP2)).isNull(); } @Test public void testUndertowHttp2Enabled() { props.getHttp().setVersion(JHipsterProperties.Http.Version.V_2_0); UndertowEmbeddedServletContainerFactory container = new UndertowEmbeddedServletContainerFactory(); webConfigurer.customize(container); Builder builder = Undertow.builder(); container.getBuilderCustomizers().forEach(c -> c.customize(builder)); OptionMap.Builder serverOptions = (OptionMap.Builder) ReflectionTestUtils.getField(builder, "serverOptions"); assertThat(serverOptions.getMap().get(UndertowOptions.ENABLE_HTTP2)).isTrue(); }
### Question: WebConfigurer implements ServletContextInitializer, EmbeddedServletContainerCustomizer { @Override public void onStartup(ServletContext servletContext) throws ServletException { if (env.getActiveProfiles().length != 0) { log.info("Web application configuration, using profiles: {}", (Object[]) env.getActiveProfiles()); } EnumSet<DispatcherType> disps = EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.ASYNC); initMetrics(servletContext, disps); if (env.acceptsProfiles(JHipsterConstants.SPRING_PROFILE_PRODUCTION)) { initCachingHttpHeadersFilter(servletContext, disps); } if (env.acceptsProfiles(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT)) { initH2Console(servletContext); } log.info("Web application fully configured"); } WebConfigurer(Environment env, JHipsterProperties jHipsterProperties); @Override void onStartup(ServletContext servletContext); @Override void customize(ConfigurableEmbeddedServletContainer container); @Bean CorsFilter corsFilter(); @Autowired(required = false) void setMetricRegistry(MetricRegistry metricRegistry); }### Answer: @Test public void testStartUpProdServletContext() throws ServletException { env.setActiveProfiles(JHipsterConstants.SPRING_PROFILE_PRODUCTION); webConfigurer.onStartup(servletContext); assertThat(servletContext.getAttribute(InstrumentedFilter.REGISTRY_ATTRIBUTE)).isEqualTo(metricRegistry); assertThat(servletContext.getAttribute(MetricsServlet.METRICS_REGISTRY)).isEqualTo(metricRegistry); verify(servletContext).addFilter(eq("webappMetricsFilter"), any(InstrumentedFilter.class)); verify(servletContext).addServlet(eq("metricsServlet"), any(MetricsServlet.class)); verify(servletContext).addFilter(eq("cachingHttpHeadersFilter"), any(CachingHttpHeadersFilter.class)); verify(servletContext, never()).addServlet(eq("H2Console"), any(WebServlet.class)); } @Test public void testStartUpDevServletContext() throws ServletException { env.setActiveProfiles(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT); webConfigurer.onStartup(servletContext); assertThat(servletContext.getAttribute(InstrumentedFilter.REGISTRY_ATTRIBUTE)).isEqualTo(metricRegistry); assertThat(servletContext.getAttribute(MetricsServlet.METRICS_REGISTRY)).isEqualTo(metricRegistry); verify(servletContext).addFilter(eq("webappMetricsFilter"), any(InstrumentedFilter.class)); verify(servletContext).addServlet(eq("metricsServlet"), any(MetricsServlet.class)); verify(servletContext, never()).addFilter(eq("cachingHttpHeadersFilter"), any(CachingHttpHeadersFilter.class)); verify(servletContext).addServlet(eq("H2Console"), any(WebServlet.class)); }
### Question: Post extends AuditableEntity { @PrePersist public void slugify(){ this.slug = new Slugify().slugify(this.title); } @PrePersist void slugify(); }### Answer: @Test public void testSlug() { System.out.println("getSlug"); Post instance = new Post(); instance.setTitle("test post 1"); instance.slugify(); assertEquals("test-post-1", instance.getSlug()); }
### Question: PostService { public Post createPost(PostForm form) { Post _post = Post.builder() .title(form.getTitle()) .content(form.getContent()) .build(); Post saved = this.postRepository.save(_post); return saved; } Post createPost(PostForm form); Post updatePost(String slug, PostForm form); void deletePost(String slug); }### Answer: @Test public void createPost() { final String TITLE = "test post title"; final String CONTENT = "test post content"; final PostForm input = PostForm.builder().title(TITLE).content(CONTENT).build(); Post expected = Post.builder().title(TITLE).content(CONTENT).build(); expected.setId(1L); given(posts.save(Post.builder().title(input.getTitle()).content(input.getContent()).build())) .willReturn(expected); Post returned = postService.createPost(input); assertTrue(returned == expected); verify(posts, times(1)).save(any(Post.class)); verifyNoMoreInteractions(posts); }
### Question: UserServiceClient { public User findByUsername(String username) { try { ResponseEntity<User> response = this.restTemplate.getForEntity(userServiceUrl + "/users/{username}", User.class, username); return response.getBody(); } catch (HttpClientErrorException e) { if (e.getStatusCode() == NOT_FOUND) { return null; } } return null; } UserServiceClient(RestTemplateBuilder builder, ObjectMapper objectMapper); void handleSignup(SignupForm form); User findByUsername(String username); }### Answer: @Test public void testFindbyUsername() { this.server.expect(requestTo(userServiceUrl + "/users/user")) .andRespond(withSuccess(new ClassPathResource("/find-user-by-username.json"), MediaType.APPLICATION_JSON_UTF8)); User user = this.client.findByUsername("user"); assertNotNull(user); assertEquals("user", user.getUsername()); this.server.verify(); } @Test public void testFindbyUsername_notFound() { this.server.expect(requestTo(userServiceUrl + "/users/user1")) .andRespond(withStatus(NOT_FOUND)); User user = this.client.findByUsername("user1"); assertNull(user); this.server.verify(); }
### Question: GraphUIController { public void refresh() { if (dfa == null) { throw new IllegalStateException("Graph has not been built using start() yet."); } panel.renderGraph(dfa); if (!panel.isJumpToActionEnabled()) { updateStatePanel(); } } GraphUIController(VisualGraphPanel panel); void start(final DFAExecution<? extends LatticeElement> dfa); void setStatePanel(StatePanelOpen statePanel); void refresh(); void stop(); }### Answer: @Test(expected = IllegalStateException.class) public void refreshShouldNotBePossibleBeforeStart() { controller.refresh(); }
### Question: GraphUIController { public void start(final DFAExecution<? extends LatticeElement> dfa) { if (this.dfa != null) { throw new IllegalStateException("Visual graph was already built."); } this.dfa = dfa; ControlFlowGraph dfaGraph = dfa.getCFG(); List<BasicBlock> dfaBasicBlocks = dfaGraph.getBasicBlocks(); Map<BasicBlock, UIBasicBlock> mappedBasicBlocks = new HashMap<>(); final List<UIAbstractBlock> uiBlocks = new ArrayList<>(); final Map<mxCell, UIAbstractBlock> mxCellMap = new HashMap<>(); for (int i = 0; i < dfaBasicBlocks.size(); i++) { BasicBlock dfaBasicBlock = dfaBasicBlocks.get(i); UIBasicBlock basicBlock = new UIBasicBlock(graph, dfaBasicBlock, dfa); uiBlocks.add(basicBlock); basicBlock.setBlockNumber(i); List<ElementaryBlock> elementaryBlocks = dfaBasicBlock.getElementaryBlocks(); if (elementaryBlocks.size() != 0) { List<UILineBlock> lineBlocks = new ArrayList<>(); ElementaryBlock firstElementaryBlock = elementaryBlocks.get(0); UILineBlock firstLineBlock = new UILineBlock(firstElementaryBlock, panel.getGraphComponent(), graph, basicBlock); lineBlocks.add(firstLineBlock); uiBlocks.add(firstLineBlock); firstLineBlock.setBlockNumber(0); basicBlock.insertLineBlock(lineBlocks.get(0)); mappedAbstractBlocks.put(firstElementaryBlock, firstLineBlock); for (int n = 1; n < elementaryBlocks.size(); n++) { ElementaryBlock currentElementaryBlock = elementaryBlocks.get(n); UILineBlock newLineBlock = new UILineBlock(currentElementaryBlock, panel.getGraphComponent(), graph, basicBlock, lineBlocks.get(n - 1)); lineBlocks.add(newLineBlock); uiBlocks.add(newLineBlock); newLineBlock.setBlockNumber(n); basicBlock.insertLineBlock(lineBlocks.get(n)); mappedAbstractBlocks.put(currentElementaryBlock, newLineBlock); } } mappedAbstractBlocks.put(dfaBasicBlock, basicBlock); mappedBasicBlocks.put(dfaBasicBlock, basicBlock); panel.insertBasicBlock(basicBlock); } panel.setBlockMap(mappedAbstractBlocks); for (BasicBlock dfaBasicBlock : dfaBasicBlocks) { UIBasicBlock currentBlock = mappedBasicBlocks.get(dfaBasicBlock); List<UIBasicBlock> successors = new ArrayList<>(); for (BasicBlock dfaSuccessor : dfaGraph.getSuccessors(dfaBasicBlock)) { successors.add(mappedBasicBlocks.get(dfaSuccessor)); } for (UIBasicBlock successor : successors) { panel.insertEdge(new UIEdge(graph, currentBlock, successor)); } } panel.renderGraph(dfa); for (UIAbstractBlock block : uiBlocks) { mxCellMap.put(block.getMxCell(), block); } graph.getSelectionModel().addListener(mxEvent.CHANGE, new mxEventSource.mxIEventListener() { @Override public void invoke(Object o, mxEventObject mxEventObject) { @SuppressWarnings("unchecked") ArrayList<mxCell> selectedCells = (ArrayList<mxCell>) mxEventObject.getProperty("removed"); if (selectedCells != null && selectedCells.size() > 0) { mxCell selectedCell = selectedCells.get(0); panel.setSelectedBlock(mxCellMap.get(selectedCell)); } else { panel.setSelectedBlock(null); } updateStatePanel(); } }); } GraphUIController(VisualGraphPanel panel); void start(final DFAExecution<? extends LatticeElement> dfa); void setStatePanel(StatePanelOpen statePanel); void refresh(); void stop(); }### Answer: @Test(expected = IllegalStateException.class) public void startShouldNotBePossibleTwice() { CodeProcessor codeProcessor = new CodeProcessor("void emptyInside() {}"); GraphBuilder builder = new GraphBuilder(codeProcessor.getPath(), codeProcessor.getClassName()); SimpleBlockGraph blockGraph = builder.buildGraph("void emptyInside()"); DFAExecution<DummyElement> dfa = new DFAExecution<>(new DummyFactory(), new NaiveWorklist(), blockGraph, new DFAPrecalcController()); controller.start(dfa); controller.start(dfa); }
### Question: Tracing extends org.apache.cassandra.tracing.Tracing { Span spanFromPayload(Tracer tracer, @Nullable Map<String, ByteBuffer> payload) { ByteBuffer b3 = payload != null ? payload.get("b3") : null; if (b3 == null) return tracer.nextSpan(); TraceContextOrSamplingFlags extracted = B3SingleFormat.parseB3SingleFormat(UTF_8.decode(b3)); if (extracted == null) return tracer.nextSpan(); return tracer.nextSpan(extracted); } Tracing(brave.Tracing tracing); Tracing(); @Override final TraceState begin( String request, InetAddress client, Map<String, String> parameters); @Override final void trace(ByteBuffer sessionId, String message, int ttl); }### Answer: @Test public void spanFromPayload_startsTraceOnNullPayload() { assertThat(cassandraTracing.spanFromPayload(tracing.tracer(), null)) .isNotNull(); } @Test public void spanFromPayload_startsTraceOnAbsentB3SingleEntry() { assertThat(cassandraTracing.spanFromPayload(tracing.tracer(), Collections.emptyMap())) .isNotNull(); } @Test public void spanFromPayload_resumesTraceOnB3SingleEntry() { assertThat(cassandraTracing.spanFromPayload(tracing.tracer(), Collections.singletonMap("b3", ByteBuffer.wrap(new byte[] {'0'})))) .extracting(b -> b.isNoop()) .isEqualTo(Boolean.TRUE); }
### Question: HashTableHipsterDirectedGraph extends HashTableHipsterGraph<V,E> implements HipsterDirectedGraph<V,E> { @Override public GraphEdge<V,E> connect(V v1, V v2, E value){ Preconditions.checkArgument(v1 != null && v2 != null, "Vertices cannot be null"); GraphEdge<V,E> edge = new DirectedEdge<V, E>(v1, v2, value); graphTable.put(v1, v2, edge); disconnected.remove(v1); disconnected.remove(v2); return edge; } @Override GraphEdge<V,E> connect(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> outgoingEdgesOf(V vertex); @Override Iterable<GraphEdge<V, E>> incomingEdgesOf(V vertex); static HashTableHipsterDirectedGraph<V, E> create(); }### Answer: @Test public void testConnect() throws Exception { directedGraph.connect("F", "G", 1d); assertEquals("F", directedGraph.incomingEdgesOf("G").iterator().next().getVertex1()); }
### Question: HashBasedHipsterGraph implements HipsterMutableGraph<V,E> { @Override public boolean add(V v){ if(!connected.containsKey(v)){ connected.put(v, new LinkedHashSet<GraphEdge<V, E>>()); return true; } return false; } HashBasedHipsterGraph(); @Override boolean add(V v); @Override Set<V> add(V... vertices); @Override boolean remove(V v); @Override Set<V> remove(V... vertices); @Override GraphEdge<V,E> connect(V v1, V v2, E value); GraphEdge<V,E> buildEdge(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> edges(); @Override Iterable<V> vertices(); @Override Iterable<GraphEdge<V, E>> edgesOf(V vertex); HashMap<V, Set<GraphEdge<V, E>>> getConnected(); void setConnected(HashMap<V, Set<GraphEdge<V, E>>> connected); static HashBasedHipsterGraph<V, E> create(); }### Answer: @Test public void testEdgesWithDisconnectedVertices() throws Exception { graph.add("X"); graph.add("Y"); testGraphEdges(); } @Test public void testAdd() throws Exception { graph.add("X"); Set vertices = Sets.newHashSet(graph.vertices()); assertTrue(vertices.contains("X")); assertTrue(vertices.size()==size+1); }
### Question: HashBasedHipsterGraph implements HipsterMutableGraph<V,E> { @Override public boolean remove(V v){ Set<GraphEdge<V, E>> edges = this.connected.get(v); if (edges == null) return false; for(Iterator<GraphEdge<V,E>> it = edges.iterator(); it.hasNext(); ){ GraphEdge<V,E> edge = it.next(); it.remove(); V v2 = edge.getVertex1().equals(v) ? edge.getVertex2() : edge.getVertex1(); for(Iterator<GraphEdge<V,E>> it2 = this.connected.get(v2).iterator(); it2.hasNext();){ GraphEdge<V,E> edge2 = it2.next(); if (edge2.getVertex1().equals(v) || edge2.getVertex2().equals(v)){ it2.remove(); } } } this.connected.remove(v); return true; } HashBasedHipsterGraph(); @Override boolean add(V v); @Override Set<V> add(V... vertices); @Override boolean remove(V v); @Override Set<V> remove(V... vertices); @Override GraphEdge<V,E> connect(V v1, V v2, E value); GraphEdge<V,E> buildEdge(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> edges(); @Override Iterable<V> vertices(); @Override Iterable<GraphEdge<V, E>> edgesOf(V vertex); HashMap<V, Set<GraphEdge<V, E>>> getConnected(); void setConnected(HashMap<V, Set<GraphEdge<V, E>>> connected); static HashBasedHipsterGraph<V, E> create(); }### Answer: @Test public void testRemove() throws Exception { graph.remove("v1"); assertFalse(Sets.newHashSet(graph.vertices()).contains("v1")); }
### Question: HashBasedHipsterGraph implements HipsterMutableGraph<V,E> { @Override public GraphEdge<V,E> connect(V v1, V v2, E value){ if(v1 == null || v2 == null) throw new IllegalArgumentException("Invalid vertices. A vertex cannot be null"); if (!connected.containsKey(v1)) throw new IllegalArgumentException(v1 + " is not a vertex of the graph"); if (!connected.containsKey(v2)) throw new IllegalArgumentException(v2 + " is not a vertex of the graph"); GraphEdge<V,E> edge = buildEdge(v1, v2, value); connected.get(v1).add(edge); connected.get(v2).add(edge); return edge; } HashBasedHipsterGraph(); @Override boolean add(V v); @Override Set<V> add(V... vertices); @Override boolean remove(V v); @Override Set<V> remove(V... vertices); @Override GraphEdge<V,E> connect(V v1, V v2, E value); GraphEdge<V,E> buildEdge(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> edges(); @Override Iterable<V> vertices(); @Override Iterable<GraphEdge<V, E>> edgesOf(V vertex); HashMap<V, Set<GraphEdge<V, E>>> getConnected(); void setConnected(HashMap<V, Set<GraphEdge<V, E>>> connected); static HashBasedHipsterGraph<V, E> create(); }### Answer: @Test public void testConnect() throws Exception { graph.add("X"); graph.add("Y"); graph.connect("X","Y",1.0d); assertTrue(Sets.newHashSet(graph.vertices()).contains("X")); assertTrue(Sets.newHashSet(graph.vertices()).contains("Y")); }
### Question: HashBasedHipsterGraph implements HipsterMutableGraph<V,E> { @Override public Iterable<V> vertices() { return connected.keySet(); } HashBasedHipsterGraph(); @Override boolean add(V v); @Override Set<V> add(V... vertices); @Override boolean remove(V v); @Override Set<V> remove(V... vertices); @Override GraphEdge<V,E> connect(V v1, V v2, E value); GraphEdge<V,E> buildEdge(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> edges(); @Override Iterable<V> vertices(); @Override Iterable<GraphEdge<V, E>> edgesOf(V vertex); HashMap<V, Set<GraphEdge<V, E>>> getConnected(); void setConnected(HashMap<V, Set<GraphEdge<V, E>>> connected); static HashBasedHipsterGraph<V, E> create(); }### Answer: @Test public void testVertices() throws Exception { Set vertices = Sets.newHashSet(graph.vertices()); assertEquals(size, vertices.size()); }
### Question: HashBasedHipsterGraph implements HipsterMutableGraph<V,E> { @Override public Iterable<GraphEdge<V, E>> edgesOf(V vertex) { Set<GraphEdge<V, E>> set = connected.get(vertex); if (set == null) set = Collections.emptySet(); return set; } HashBasedHipsterGraph(); @Override boolean add(V v); @Override Set<V> add(V... vertices); @Override boolean remove(V v); @Override Set<V> remove(V... vertices); @Override GraphEdge<V,E> connect(V v1, V v2, E value); GraphEdge<V,E> buildEdge(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> edges(); @Override Iterable<V> vertices(); @Override Iterable<GraphEdge<V, E>> edgesOf(V vertex); HashMap<V, Set<GraphEdge<V, E>>> getConnected(); void setConnected(HashMap<V, Set<GraphEdge<V, E>>> connected); static HashBasedHipsterGraph<V, E> create(); }### Answer: @Test public void testEdgesOf() throws Exception { Set edges = Sets.newHashSet(graph.edgesOf("v1")); assertEquals(size-1, edges.size()); }
### Question: HashBasedHipsterDirectedGraph extends HashBasedHipsterGraph<V, E> implements HipsterMutableGraph<V, E>, HipsterDirectedGraph<V, E> { @Override public Iterable<GraphEdge<V, E>> outgoingEdgesOf(final V vertex) { return F.filter(edgesOf(vertex), new Function<GraphEdge<V, E>, Boolean>() { @Override public Boolean apply(GraphEdge<V, E> edge) { return edge.getVertex1().equals(vertex); } }); } @Override GraphEdge<V, E> buildEdge(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> outgoingEdgesOf(final V vertex); @Override Iterable<GraphEdge<V, E>> incomingEdgesOf(final V vertex); @Override Iterable<GraphEdge<V, E>> edges(); static HashBasedHipsterDirectedGraph<V, E> create(); }### Answer: @Test public void testOutgoingEdgesOf() throws Exception { for(int i=0; i<size; i++) { Set edges = Sets.newHashSet(graph.outgoingEdgesOf("v"+i)); assertEquals(size-(i+1), edges.size()); } }
### Question: HashBasedHipsterDirectedGraph extends HashBasedHipsterGraph<V, E> implements HipsterMutableGraph<V, E>, HipsterDirectedGraph<V, E> { @Override public Iterable<GraphEdge<V, E>> incomingEdgesOf(final V vertex) { return F.filter(edgesOf(vertex), new Function<GraphEdge<V, E>, Boolean>() { @Override public Boolean apply(GraphEdge<V, E> edge) { return edge.getVertex2().equals(vertex); } }); } @Override GraphEdge<V, E> buildEdge(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> outgoingEdgesOf(final V vertex); @Override Iterable<GraphEdge<V, E>> incomingEdgesOf(final V vertex); @Override Iterable<GraphEdge<V, E>> edges(); static HashBasedHipsterDirectedGraph<V, E> create(); }### Answer: @Test public void testIncomingEdgesOf() throws Exception { for(int i=0; i<size; i++) { Set edges = Sets.newHashSet(graph.incomingEdgesOf("v"+i)); assertEquals(i, edges.size()); } }
### Question: HashBasedHipsterDirectedGraph extends HashBasedHipsterGraph<V, E> implements HipsterMutableGraph<V, E>, HipsterDirectedGraph<V, E> { @Override public Iterable<GraphEdge<V, E>> edges() { return F.map( F.filter(HashBasedHipsterDirectedGraph.super.vedges(), new Function<Map.Entry<V, GraphEdge<V, E>>, Boolean>() { @Override public Boolean apply(Map.Entry<V, GraphEdge<V, E>> input) { return input.getKey().equals(input.getValue().getVertex1()); } }), new Function<Map.Entry<V, GraphEdge<V, E>>, GraphEdge<V, E>>() { @Override public GraphEdge<V, E> apply(Map.Entry<V, GraphEdge<V, E>> input) { return input.getValue(); } }); } @Override GraphEdge<V, E> buildEdge(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> outgoingEdgesOf(final V vertex); @Override Iterable<GraphEdge<V, E>> incomingEdgesOf(final V vertex); @Override Iterable<GraphEdge<V, E>> edges(); static HashBasedHipsterDirectedGraph<V, E> create(); }### Answer: @Test public void testEdges() throws Exception { Set edges = Sets.newHashSet(graph.edges()); assertEquals(size*(size-1)/2, edges.size()); }
### Question: HashTableHipsterDirectedGraph extends HashTableHipsterGraph<V,E> implements HipsterDirectedGraph<V,E> { @Override public Iterable<GraphEdge<V, E>> outgoingEdgesOf(V vertex) { return graphTable.row(vertex).values(); } @Override GraphEdge<V,E> connect(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> outgoingEdgesOf(V vertex); @Override Iterable<GraphEdge<V, E>> incomingEdgesOf(V vertex); static HashTableHipsterDirectedGraph<V, E> create(); }### Answer: @Test public void testOutgoingEdgesOf() throws Exception { Set<DirectedEdge<String, Double>> expected = new HashSet<DirectedEdge<String, Double>>(); expected.add(new DirectedEdge<String, Double>("B", "C", 5d)); expected.add(new DirectedEdge<String, Double>("B", "D", 10d)); assertEquals(expected, Sets.newHashSet(directedGraph.outgoingEdgesOf("B"))); }
### Question: HashTableHipsterDirectedGraph extends HashTableHipsterGraph<V,E> implements HipsterDirectedGraph<V,E> { @Override public Iterable<GraphEdge<V, E>> incomingEdgesOf(V vertex) { return graphTable.column(vertex).values(); } @Override GraphEdge<V,E> connect(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> outgoingEdgesOf(V vertex); @Override Iterable<GraphEdge<V, E>> incomingEdgesOf(V vertex); static HashTableHipsterDirectedGraph<V, E> create(); }### Answer: @Test public void testIncomingEdgesOf() throws Exception { Set<DirectedEdge<String, Double>> expected = new HashSet<DirectedEdge<String, Double>>(); expected.add(new DirectedEdge<String, Double>("B", "C", 5d)); expected.add(new DirectedEdge<String, Double>("A", "C", 2d)); assertEquals(expected, Sets.newHashSet(directedGraph.incomingEdgesOf("C"))); }
### Question: HashTableHipsterGraph implements HipsterGraph<V,E> { public void add(V v){ if (!graphTable.containsColumn(v) && !graphTable.containsRow(v)){ disconnected.add(v); } } void add(V v); void remove(V v); void remove(V v, GraphEdge<V,E> edge); GraphEdge<V,E> connect(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> edges(); @Override Iterable<V> vertices(); @Override Iterable<GraphEdge<V, E>> edgesOf(V vertex); static HashTableHipsterGraph<V, E> create(); }### Answer: @Test public void testAdd() throws Exception { graph.add("G"); assertTrue(Sets.newHashSet(graph.vertices()).contains("G")); }
### Question: HashTableHipsterGraph implements HipsterGraph<V,E> { public void remove(V v){ for(GraphEdge<V,E> edge : edgesOf(v)){ V connectedVertex = edge.getVertex1().equals(v) ? edge.getVertex2() : edge.getVertex1(); if (!greaterThan(1, edgesOf(connectedVertex))){ disconnected.add(connectedVertex); } } if (graphTable.containsRow(v)){ graphTable.row(v).clear(); } if (graphTable.containsColumn(v)){ graphTable.column(v).clear(); } disconnected.remove(v); } void add(V v); void remove(V v); void remove(V v, GraphEdge<V,E> edge); GraphEdge<V,E> connect(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> edges(); @Override Iterable<V> vertices(); @Override Iterable<GraphEdge<V, E>> edgesOf(V vertex); static HashTableHipsterGraph<V, E> create(); }### Answer: @Test public void testRemove() throws Exception { graph.remove("B"); assertFalse(Sets.newHashSet(graph.vertices()).contains("B")); }
### Question: HashTableHipsterGraph implements HipsterGraph<V,E> { public GraphEdge<V,E> connect(V v1, V v2, E value){ Preconditions.checkArgument(v1 != null && v2 != null, "Vertices cannot be null"); GraphEdge<V,E> edge = new UndirectedEdge<V, E>(v1, v2, value); graphTable.put(v1, v2, edge); graphTable.put(v2, v1, edge); disconnected.remove(v1); disconnected.remove(v2); return edge; } void add(V v); void remove(V v); void remove(V v, GraphEdge<V,E> edge); GraphEdge<V,E> connect(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> edges(); @Override Iterable<V> vertices(); @Override Iterable<GraphEdge<V, E>> edgesOf(V vertex); static HashTableHipsterGraph<V, E> create(); }### Answer: @Test public void testConnect() throws Exception { graph.connect("X","Y",1.0d); assertTrue(Sets.newHashSet(graph.vertices()).contains("X")); assertTrue(Sets.newHashSet(graph.vertices()).contains("Y")); }
### Question: HashTableHipsterGraph implements HipsterGraph<V,E> { @Override public Iterable<GraphEdge<V, E>> edges() { return graphTable.values(); } void add(V v); void remove(V v); void remove(V v, GraphEdge<V,E> edge); GraphEdge<V,E> connect(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> edges(); @Override Iterable<V> vertices(); @Override Iterable<GraphEdge<V, E>> edgesOf(V vertex); static HashTableHipsterGraph<V, E> create(); }### Answer: @Test public void testEdges() throws Exception { Set<GraphEdge<String,Double>> expected = new HashSet<GraphEdge<String, Double>>(); expected.add(new UndirectedEdge<String, Double>("A","B",4d)); expected.add(new UndirectedEdge<String, Double>("A","C",2d)); expected.add(new UndirectedEdge<String, Double>("B","C",5d)); expected.add(new UndirectedEdge<String, Double>("B","D",10d)); expected.add(new UndirectedEdge<String, Double>("C","E",3d)); expected.add(new UndirectedEdge<String, Double>("D","F",11d)); expected.add(new UndirectedEdge<String, Double>("E","D",4d)); assertEquals(expected, Sets.newHashSet(graph.edges())); }
### Question: HashTableHipsterGraph implements HipsterGraph<V,E> { @Override public Iterable<V> vertices() { return Sets.union(Sets.union(graphTable.rowKeySet(), graphTable.columnKeySet()), disconnected); } void add(V v); void remove(V v); void remove(V v, GraphEdge<V,E> edge); GraphEdge<V,E> connect(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> edges(); @Override Iterable<V> vertices(); @Override Iterable<GraphEdge<V, E>> edgesOf(V vertex); static HashTableHipsterGraph<V, E> create(); }### Answer: @Test public void testVertices() throws Exception { Set<String> expected = Sets.newHashSet("A","B","C","D","E","F"); assertEquals(expected, graph.vertices()); }
### Question: HashTableHipsterGraph implements HipsterGraph<V,E> { @Override public Iterable<GraphEdge<V, E>> edgesOf(V vertex) { return Sets.union(Sets.newHashSet(graphTable.row(vertex).values()), Sets.newHashSet(graphTable.column(vertex).values())); } void add(V v); void remove(V v); void remove(V v, GraphEdge<V,E> edge); GraphEdge<V,E> connect(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> edges(); @Override Iterable<V> vertices(); @Override Iterable<GraphEdge<V, E>> edgesOf(V vertex); static HashTableHipsterGraph<V, E> create(); }### Answer: @Test public void testEdgesOf() throws Exception { Set<GraphEdge<String,Double>> expected = new HashSet<GraphEdge<String, Double>>(); expected.add(new UndirectedEdge<String, Double>("B","D",10d)); expected.add(new UndirectedEdge<String, Double>("A","B",4d)); expected.add(new UndirectedEdge<String, Double>("B","C",5d)); assertEquals(expected, graph.edgesOf("B")); }
### Question: HashBasedHipsterGraph implements HipsterMutableGraph<V,E> { @Override public Iterable<GraphEdge<V, E>> edges() { return F.map(vedges(), new Function<Map.Entry<V, GraphEdge<V, E>>, GraphEdge<V, E>>() { @Override public GraphEdge<V, E> apply(Map.Entry<V, GraphEdge<V, E>> entry) { return entry.getValue(); } }); } HashBasedHipsterGraph(); @Override boolean add(V v); @Override Set<V> add(V... vertices); @Override boolean remove(V v); @Override Set<V> remove(V... vertices); @Override GraphEdge<V,E> connect(V v1, V v2, E value); GraphEdge<V,E> buildEdge(V v1, V v2, E value); @Override Iterable<GraphEdge<V, E>> edges(); @Override Iterable<V> vertices(); @Override Iterable<GraphEdge<V, E>> edgesOf(V vertex); HashMap<V, Set<GraphEdge<V, E>>> getConnected(); void setConnected(HashMap<V, Set<GraphEdge<V, E>>> connected); static HashBasedHipsterGraph<V, E> create(); }### Answer: @Test public void testEdges() throws Exception { testGraphEdges(); }
### Question: CallArgumentsToByteArray { public byte[] getGasPrice() { byte[] gasPrice = new byte[] {0}; if (args.gasPrice != null && args.gasPrice.length() != 0) { gasPrice = stringHexToByteArray(args.gasPrice); } return gasPrice; } CallArgumentsToByteArray(Web3.CallArguments args); byte[] getGasPrice(); byte[] getGasLimit(); byte[] getToAddress(); byte[] getValue(); byte[] getData(); RskAddress getFromAddress(); }### Answer: @Test public void getGasPriceWhenValueIsNull() throws Exception { Web3.CallArguments args = new Web3.CallArguments(); CallArgumentsToByteArray byteArrayArgs = new CallArgumentsToByteArray(args); Assert.assertArrayEquals(new byte[] {0}, byteArrayArgs.getGasPrice()); } @Test public void getGasPriceWhenValueIsEmpty() throws Exception { Web3.CallArguments args = new Web3.CallArguments(); args.gasPrice = ""; CallArgumentsToByteArray byteArrayArgs = new CallArgumentsToByteArray(args); Assert.assertArrayEquals(new byte[] {0}, byteArrayArgs.getGasPrice()); }
### Question: BridgeSerializationUtils { public static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters) { return deserializeReleaseTransactionSet(data, networkParameters, false); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }### Answer: @Test public void deserializeTransactionSet_emptyOrNull() throws Exception { assertEquals(0, BridgeSerializationUtils.deserializeReleaseTransactionSet(null, NetworkParameters.fromID(NetworkParameters.ID_REGTEST)).getEntries().size()); assertEquals(0, BridgeSerializationUtils.deserializeReleaseTransactionSet(new byte[]{}, NetworkParameters.fromID(NetworkParameters.ID_REGTEST)).getEntries().size()); } @Test public void deserializeTransactionSet_nonEmptyOddSize() throws Exception { byte[] firstItem = RLP.encodeElement(Hex.decode("010203")); byte[] data = RLP.encodeList(firstItem); try { BridgeSerializationUtils.deserializeReleaseTransactionSet(data, NetworkParameters.fromID(NetworkParameters.ID_REGTEST)); } catch (RuntimeException e) { return; } Assert.fail(); }
### Question: Value { public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }### Answer: @Test public void isEmpty_Array() { Value val = new Value(new String[0]); assertTrue(val.isEmpty()); } @Test public void isEmpty_Null() { Value val = new Value(null); assertTrue(val.isEmpty()); } @Test public void isEmpty_EmptyString() { Value val = new Value(""); assertTrue(val.isEmpty()); } @Test public void isEmpty_Bytes() { Value val = new Value(new byte[0]); assertTrue(val.isEmpty()); }
### Question: BridgeSerializationUtils { public static byte[] serializeInteger(Integer value) { return RLP.encodeBigInteger(BigInteger.valueOf(value)); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }### Answer: @Test public void serializeInteger() { Assert.assertEquals(BigInteger.valueOf(123), RLP.decodeBigInteger(BridgeSerializationUtils.serializeInteger(123), 0)); Assert.assertEquals(BigInteger.valueOf(1200), RLP.decodeBigInteger(BridgeSerializationUtils.serializeInteger(1200), 0)); }
### Question: BridgeSerializationUtils { public static Integer deserializeInteger(byte[] data) { return RLP.decodeBigInteger(data, 0).intValue(); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }### Answer: @Test public void deserializeInteger() { Assert.assertEquals(123, BridgeSerializationUtils.deserializeInteger(RLP.encodeBigInteger(BigInteger.valueOf(123))).intValue()); Assert.assertEquals(1200, BridgeSerializationUtils.deserializeInteger(RLP.encodeBigInteger(BigInteger.valueOf(1200))).intValue()); }
### Question: LockWhitelist { public Integer getSize() { return whitelistedAddresses.size(); } LockWhitelist(Map<Address, LockWhitelistEntry> whitelistedAddresses); LockWhitelist(Map<Address, LockWhitelistEntry> whitelistedAddresses, int disableBlockHeight); boolean isWhitelisted(Address address); boolean isWhitelisted(byte[] address); boolean isWhitelistedFor(Address address, Coin amount, int height); Integer getSize(); List<Address> getAddresses(); List<T> getAll(Class<T> type); List<LockWhitelistEntry> getAll(); LockWhitelistEntry get(Address address); boolean put(Address address, LockWhitelistEntry entry); boolean remove(Address address); void consume(Address address); int getDisableBlockHeight(); void setDisableBlockHeight(int disableBlockHeight); boolean isDisableBlockSet(); }### Answer: @Test public void getSize() { Assert.assertEquals(4, whitelist.getSize().intValue()); }
### Question: LockWhitelist { public List<Address> getAddresses() { return new ArrayList<>(whitelistedAddresses.keySet()); } LockWhitelist(Map<Address, LockWhitelistEntry> whitelistedAddresses); LockWhitelist(Map<Address, LockWhitelistEntry> whitelistedAddresses, int disableBlockHeight); boolean isWhitelisted(Address address); boolean isWhitelisted(byte[] address); boolean isWhitelistedFor(Address address, Coin amount, int height); Integer getSize(); List<Address> getAddresses(); List<T> getAll(Class<T> type); List<LockWhitelistEntry> getAll(); LockWhitelistEntry get(Address address); boolean put(Address address, LockWhitelistEntry entry); boolean remove(Address address); void consume(Address address); int getDisableBlockHeight(); void setDisableBlockHeight(int disableBlockHeight); boolean isDisableBlockSet(); }### Answer: @Test public void getAddresses() { Assert.assertNotSame(whitelist.getAddresses(), addresses); Assert.assertThat(whitelist.getAddresses(), containsInAnyOrder(addresses.keySet().toArray())); }
### Question: LockWhitelist { public boolean isWhitelisted(Address address) { return whitelistedAddresses.containsKey(address); } LockWhitelist(Map<Address, LockWhitelistEntry> whitelistedAddresses); LockWhitelist(Map<Address, LockWhitelistEntry> whitelistedAddresses, int disableBlockHeight); boolean isWhitelisted(Address address); boolean isWhitelisted(byte[] address); boolean isWhitelistedFor(Address address, Coin amount, int height); Integer getSize(); List<Address> getAddresses(); List<T> getAll(Class<T> type); List<LockWhitelistEntry> getAll(); LockWhitelistEntry get(Address address); boolean put(Address address, LockWhitelistEntry entry); boolean remove(Address address); void consume(Address address); int getDisableBlockHeight(); void setDisableBlockHeight(int disableBlockHeight); boolean isDisableBlockSet(); }### Answer: @Test public void isWhitelisted() { for (Address address : addresses.keySet()) { assertExistance(address, true); } Address randomAddress = Address.fromBase58( NetworkParameters.fromID(NetworkParameters.ID_REGTEST), "n3PLxDiwWqa5uH7fSbHCxS6VAjD9Y7Rwkj" ); assertExistance(randomAddress, false); }
### Question: LockWhitelist { public boolean put(Address address, LockWhitelistEntry entry) { if (whitelistedAddresses.containsKey(address)) { return false; } whitelistedAddresses.put(address, entry); return true; } LockWhitelist(Map<Address, LockWhitelistEntry> whitelistedAddresses); LockWhitelist(Map<Address, LockWhitelistEntry> whitelistedAddresses, int disableBlockHeight); boolean isWhitelisted(Address address); boolean isWhitelisted(byte[] address); boolean isWhitelistedFor(Address address, Coin amount, int height); Integer getSize(); List<Address> getAddresses(); List<T> getAll(Class<T> type); List<LockWhitelistEntry> getAll(); LockWhitelistEntry get(Address address); boolean put(Address address, LockWhitelistEntry entry); boolean remove(Address address); void consume(Address address); int getDisableBlockHeight(); void setDisableBlockHeight(int disableBlockHeight); boolean isDisableBlockSet(); }### Answer: @Test public void addOneOff() { Address randomAddress = Address.fromBase58( NetworkParameters.fromID(NetworkParameters.ID_REGTEST), "n3WzdjG7S2GjDbY1pJYxsY1VSQDkm4KDcm" ); assertExistance(randomAddress, false); Assert.assertTrue(whitelist.put(randomAddress, new OneOffWhiteListEntry(randomAddress, Coin.CENT))); assertExistance(randomAddress, true); Assert.assertFalse(whitelist.put(randomAddress, new OneOffWhiteListEntry(randomAddress, Coin.CENT))); } @Test public void addUnlimited() { Address randomAddress = Address.fromBase58( NetworkParameters.fromID(NetworkParameters.ID_REGTEST), "n3WzdjG7S2GjDbY1pJYxsY1VSQDkm4KDcm" ); assertExistance(randomAddress, false); Assert.assertTrue(whitelist.put(randomAddress, new UnlimitedWhiteListEntry(randomAddress))); assertExistance(randomAddress, true); Assert.assertFalse(whitelist.put(randomAddress, new UnlimitedWhiteListEntry(randomAddress))); } @Test public void addOneOffAfterUnlimited() { Address randomAddress = Address.fromBase58( NetworkParameters.fromID(NetworkParameters.ID_REGTEST), "n3WzdjG7S2GjDbY1pJYxsY1VSQDkm4KDcm" ); assertExistance(randomAddress, false); Assert.assertTrue(whitelist.put(randomAddress, new UnlimitedWhiteListEntry(randomAddress))); assertExistance(randomAddress, true); Assert.assertFalse(whitelist.put(randomAddress, new OneOffWhiteListEntry(randomAddress, Coin.CENT))); }
### Question: LockWhitelist { public boolean remove(Address address) { return whitelistedAddresses.remove(address) != null; } LockWhitelist(Map<Address, LockWhitelistEntry> whitelistedAddresses); LockWhitelist(Map<Address, LockWhitelistEntry> whitelistedAddresses, int disableBlockHeight); boolean isWhitelisted(Address address); boolean isWhitelisted(byte[] address); boolean isWhitelistedFor(Address address, Coin amount, int height); Integer getSize(); List<Address> getAddresses(); List<T> getAll(Class<T> type); List<LockWhitelistEntry> getAll(); LockWhitelistEntry get(Address address); boolean put(Address address, LockWhitelistEntry entry); boolean remove(Address address); void consume(Address address); int getDisableBlockHeight(); void setDisableBlockHeight(int disableBlockHeight); boolean isDisableBlockSet(); }### Answer: @Test public void remove() { Assert.assertTrue(whitelist.isWhitelisted(existingAddress)); Assert.assertTrue(whitelist.isWhitelisted(existingAddress.getHash160())); Assert.assertTrue(whitelist.remove(existingAddress)); Assert.assertFalse(whitelist.isWhitelisted(existingAddress)); Assert.assertFalse(whitelist.isWhitelisted(existingAddress.getHash160())); Assert.assertFalse(whitelist.remove(existingAddress)); }
### Question: LockWhitelist { public void consume(Address address) { LockWhitelistEntry entry = whitelistedAddresses.get(address); if (entry == null) { return; } entry.consume(); if (entry.isConsumed()) { this.remove(address); } } LockWhitelist(Map<Address, LockWhitelistEntry> whitelistedAddresses); LockWhitelist(Map<Address, LockWhitelistEntry> whitelistedAddresses, int disableBlockHeight); boolean isWhitelisted(Address address); boolean isWhitelisted(byte[] address); boolean isWhitelistedFor(Address address, Coin amount, int height); Integer getSize(); List<Address> getAddresses(); List<T> getAll(Class<T> type); List<LockWhitelistEntry> getAll(); LockWhitelistEntry get(Address address); boolean put(Address address, LockWhitelistEntry entry); boolean remove(Address address); void consume(Address address); int getDisableBlockHeight(); void setDisableBlockHeight(int disableBlockHeight); boolean isDisableBlockSet(); }### Answer: @Test public void consume() { assertExistance(existingAddress, true); whitelist.consume(existingAddress); assertExistance(existingAddress, false); Assert.assertFalse(whitelist.remove(existingAddress)); } @Test public void cantLockOneOffAfterConsume() { Address randomAddress = Address.fromBase58( NetworkParameters.fromID(NetworkParameters.ID_REGTEST), "n3WzdjG7S2GjDbY1pJYxsY1VSQDkm4KDcm" ); OneOffWhiteListEntry entry = new OneOffWhiteListEntry(randomAddress, Coin.COIN); Assert.assertTrue(entry.canLock(Coin.COIN)); entry.consume(); Assert.assertFalse(entry.canLock(Coin.COIN)); } @Test public void canLockUnlimitedAfterConsume() { Address randomAddress = Address.fromBase58( NetworkParameters.fromID(NetworkParameters.ID_REGTEST), "n3WzdjG7S2GjDbY1pJYxsY1VSQDkm4KDcm" ); UnlimitedWhiteListEntry entry = new UnlimitedWhiteListEntry(randomAddress); Assert.assertTrue(entry.canLock(Coin.COIN)); entry.consume(); Assert.assertTrue(entry.canLock(Coin.COIN)); }
### Question: RLP { public static byte[] decodeIP4Bytes(byte[] data, int index) { int offset = 1; final byte[] result = new byte[4]; for (int i = 0; i < 4; i++) { result[i] = decodeOneByteItem(data, index + offset); if ((data[index + offset] & 0xFF) > OFFSET_SHORT_ITEM) { offset += 2; } else { offset += 1; } } return result; } static int decodeInt(byte[] data, int index); static BigInteger decodeBigInteger(byte[] data, int index); static byte[] decodeIP4Bytes(byte[] data, int index); static int getFirstListElement(byte[] payload, int pos); static int getNextElementIndex(byte[] payload, int pos); static void fullTraverse(byte[] msgData, int level, int startPos, int endPos, int levelToIndex, Queue<Integer> index); @Nonnull static ArrayList<RLPElement> decode2(@CheckForNull byte[] msgData); static RLPElement decodeFirstElement(@CheckForNull byte[] msgData, int position); static RLPList decodeList(byte[] msgData); @Nullable static RLPElement decode2OneItem(@CheckForNull byte[] msgData, int startPos); @Nonnull static RskAddress parseRskAddress(@Nullable byte[] bytes); @Nonnull static Coin parseCoin(@Nullable byte[] bytes); @Nullable static Coin parseCoinNonNullZero(byte[] bytes); @Nullable static Coin parseSignedCoinNonNullZero(byte[] bytes); static Coin parseCoinNullZero(@Nullable byte[] bytes); @Nullable static BlockDifficulty parseBlockDifficulty(@Nullable byte[] bytes); static byte[] encode(Object input); static byte[] encodeLength(int length, int offset); static byte[] encodeByte(byte singleByte); static byte[] encodeShort(short singleShort); static byte[] encodeInt(int singleInt); static byte[] encodeString(String srcString); static byte[] encodeBigInteger(BigInteger srcBigInteger); static byte[] encodeRskAddress(RskAddress addr); static byte[] encodeCoin(@Nullable Coin coin); static byte[] encodeCoinNonNullZero(@CheckForNull Coin coin); static byte[] encodeSignedCoinNonNullZero(@CheckForNull Coin coin); static byte[] encodeCoinNullZero(Coin coin); static byte[] encodeBlockDifficulty(BlockDifficulty difficulty); static byte[] encodeElement(@Nullable byte[] srcData); static byte[] encodeListHeader(int size); static byte[] encodeSet(Set<ByteArrayWrapper> data); static byte[] encodeList(byte[]... elements); static byte[] encodedEmptyList(); static byte[] encodedEmptyByteArray(); }### Answer: @Test public void test1() throws UnknownHostException { String peersPacket = "F8 4E 11 F8 4B C5 36 81 " + "CC 0A 29 82 76 5F B8 40 D8 D6 0C 25 80 FA 79 5C " + "FC 03 13 EF DE BA 86 9D 21 94 E7 9E 7C B2 B5 22 " + "F7 82 FF A0 39 2C BB AB 8D 1B AC 30 12 08 B1 37 " + "E0 DE 49 98 33 4F 3B CF 73 FA 11 7E F2 13 F8 74 " + "17 08 9F EA F8 4C 21 B0"; byte[] payload = Hex.decode(peersPacket); byte[] ip = decodeIP4Bytes(payload, 5); assertEquals(InetAddress.getByAddress(ip).toString(), ("/54.204.10.41")); }
### Question: LockWhitelist { public <T extends LockWhitelistEntry> List<T> getAll(Class<T> type) { return whitelistedAddresses.values().stream() .filter(e -> e.getClass() == type) .map(type::cast) .collect(Collectors.toList()); } LockWhitelist(Map<Address, LockWhitelistEntry> whitelistedAddresses); LockWhitelist(Map<Address, LockWhitelistEntry> whitelistedAddresses, int disableBlockHeight); boolean isWhitelisted(Address address); boolean isWhitelisted(byte[] address); boolean isWhitelistedFor(Address address, Coin amount, int height); Integer getSize(); List<Address> getAddresses(); List<T> getAll(Class<T> type); List<LockWhitelistEntry> getAll(); LockWhitelistEntry get(Address address); boolean put(Address address, LockWhitelistEntry entry); boolean remove(Address address); void consume(Address address); int getDisableBlockHeight(); void setDisableBlockHeight(int disableBlockHeight); boolean isDisableBlockSet(); }### Answer: @Test public void getAllByType() { Assert.assertArrayEquals( addresses.values().stream().filter(e -> e.getClass() == OneOffWhiteListEntry.class).map(e-> e.address()).sorted().toArray(), whitelist.getAll(OneOffWhiteListEntry.class).stream().map(e-> e.address()).toArray() ); Assert.assertArrayEquals( addresses.values().stream().filter(e -> e.getClass() == UnlimitedWhiteListEntry.class).map(e-> e.address()).sorted().toArray(), whitelist.getAll(UnlimitedWhiteListEntry.class).stream().map(e-> e.address()).toArray() ); } @Test public void getAll() { Assert.assertEquals(addresses.size(), whitelist.getAll().size()); }
### Question: CoinbaseInformation { public Sha256Hash getWitnessMerkleRoot() { return witnessMerkleRoot; } CoinbaseInformation(Sha256Hash witnessMerkleRoot); Sha256Hash getWitnessMerkleRoot(); }### Answer: @Test public void getWitnessMerkleRoot() { Sha256Hash secondHashTx = Sha256Hash.wrap(Hex.decode("e3d0840a0825fb7d880e5cb8306745352920a8c7e8a30fac882b275e26c6bb65")); Sha256Hash witnessRoot = MerkleTreeUtils.combineLeftRight(Sha256Hash.ZERO_HASH, secondHashTx); CoinbaseInformation instance = new CoinbaseInformation(witnessRoot); Sha256Hash expectedHash = new Sha256Hash(Hex.decode("613cb22535df8d9443fe94b66d807cd60312f982e305e25e825b00e6f429799f")); Assert.assertEquals(expectedHash, instance.getWitnessMerkleRoot()); }
### Question: RLP { public static int decodeInt(byte[] data, int index) { int value = 0; if ((data[index] & 0xFF) < OFFSET_SHORT_ITEM) { return data[index]; } else if ((data[index] & 0xFF) >= OFFSET_SHORT_ITEM && (data[index] & 0xFF) < OFFSET_LONG_ITEM) { byte length = (byte) (data[index] - OFFSET_SHORT_ITEM); byte pow = (byte) (length - 1); for (int i = 1; i <= length; ++i) { value += (data[index + i] & 0xFF) << (8 * pow); pow--; } } else { throw new RuntimeException("wrong decode attempt"); } return value; } static int decodeInt(byte[] data, int index); static BigInteger decodeBigInteger(byte[] data, int index); static byte[] decodeIP4Bytes(byte[] data, int index); static int getFirstListElement(byte[] payload, int pos); static int getNextElementIndex(byte[] payload, int pos); static void fullTraverse(byte[] msgData, int level, int startPos, int endPos, int levelToIndex, Queue<Integer> index); @Nonnull static ArrayList<RLPElement> decode2(@CheckForNull byte[] msgData); static RLPElement decodeFirstElement(@CheckForNull byte[] msgData, int position); static RLPList decodeList(byte[] msgData); @Nullable static RLPElement decode2OneItem(@CheckForNull byte[] msgData, int startPos); @Nonnull static RskAddress parseRskAddress(@Nullable byte[] bytes); @Nonnull static Coin parseCoin(@Nullable byte[] bytes); @Nullable static Coin parseCoinNonNullZero(byte[] bytes); @Nullable static Coin parseSignedCoinNonNullZero(byte[] bytes); static Coin parseCoinNullZero(@Nullable byte[] bytes); @Nullable static BlockDifficulty parseBlockDifficulty(@Nullable byte[] bytes); static byte[] encode(Object input); static byte[] encodeLength(int length, int offset); static byte[] encodeByte(byte singleByte); static byte[] encodeShort(short singleShort); static byte[] encodeInt(int singleInt); static byte[] encodeString(String srcString); static byte[] encodeBigInteger(BigInteger srcBigInteger); static byte[] encodeRskAddress(RskAddress addr); static byte[] encodeCoin(@Nullable Coin coin); static byte[] encodeCoinNonNullZero(@CheckForNull Coin coin); static byte[] encodeSignedCoinNonNullZero(@CheckForNull Coin coin); static byte[] encodeCoinNullZero(Coin coin); static byte[] encodeBlockDifficulty(BlockDifficulty difficulty); static byte[] encodeElement(@Nullable byte[] srcData); static byte[] encodeListHeader(int size); static byte[] encodeSet(Set<ByteArrayWrapper> data); static byte[] encodeList(byte[]... elements); static byte[] encodedEmptyList(); static byte[] encodedEmptyByteArray(); }### Answer: @Test public void test2() throws UnknownHostException { String peersPacket = "F8 4E 11 F8 4B C5 36 81 " + "CC 0A 29 82 76 5F B8 40 D8 D6 0C 25 80 FA 79 5C " + "FC 03 13 EF DE BA 86 9D 21 94 E7 9E 7C B2 B5 22 " + "F7 82 FF A0 39 2C BB AB 8D 1B AC 30 12 08 B1 37 " + "E0 DE 49 98 33 4F 3B CF 73 FA 11 7E F2 13 F8 74 " + "17 08 9F EA F8 4C 21 B0"; byte[] payload = Hex.decode(peersPacket); int oneInt = decodeInt(payload, 11); assertEquals(oneInt, 30303); }
### Question: RLP { public static byte[] encodeByte(byte singleByte) { if ((singleByte & 0xFF) == 0) { return new byte[]{(byte) OFFSET_SHORT_ITEM}; } else if ((singleByte & 0xFF) <= 0x7F) { return new byte[]{singleByte}; } else { return new byte[]{(byte) (OFFSET_SHORT_ITEM + 1), singleByte}; } } static int decodeInt(byte[] data, int index); static BigInteger decodeBigInteger(byte[] data, int index); static byte[] decodeIP4Bytes(byte[] data, int index); static int getFirstListElement(byte[] payload, int pos); static int getNextElementIndex(byte[] payload, int pos); static void fullTraverse(byte[] msgData, int level, int startPos, int endPos, int levelToIndex, Queue<Integer> index); @Nonnull static ArrayList<RLPElement> decode2(@CheckForNull byte[] msgData); static RLPElement decodeFirstElement(@CheckForNull byte[] msgData, int position); static RLPList decodeList(byte[] msgData); @Nullable static RLPElement decode2OneItem(@CheckForNull byte[] msgData, int startPos); @Nonnull static RskAddress parseRskAddress(@Nullable byte[] bytes); @Nonnull static Coin parseCoin(@Nullable byte[] bytes); @Nullable static Coin parseCoinNonNullZero(byte[] bytes); @Nullable static Coin parseSignedCoinNonNullZero(byte[] bytes); static Coin parseCoinNullZero(@Nullable byte[] bytes); @Nullable static BlockDifficulty parseBlockDifficulty(@Nullable byte[] bytes); static byte[] encode(Object input); static byte[] encodeLength(int length, int offset); static byte[] encodeByte(byte singleByte); static byte[] encodeShort(short singleShort); static byte[] encodeInt(int singleInt); static byte[] encodeString(String srcString); static byte[] encodeBigInteger(BigInteger srcBigInteger); static byte[] encodeRskAddress(RskAddress addr); static byte[] encodeCoin(@Nullable Coin coin); static byte[] encodeCoinNonNullZero(@CheckForNull Coin coin); static byte[] encodeSignedCoinNonNullZero(@CheckForNull Coin coin); static byte[] encodeCoinNullZero(Coin coin); static byte[] encodeBlockDifficulty(BlockDifficulty difficulty); static byte[] encodeElement(@Nullable byte[] srcData); static byte[] encodeListHeader(int size); static byte[] encodeSet(Set<ByteArrayWrapper> data); static byte[] encodeList(byte[]... elements); static byte[] encodedEmptyList(); static byte[] encodedEmptyByteArray(); }### Answer: @Test public void test4() { byte[] expected = {(byte) 0x80}; byte[] data = encodeByte((byte) 0); assertArrayEquals(expected, data); byte[] expected2 = {(byte) 0x78}; data = encodeByte((byte) 120); assertArrayEquals(expected2, data); byte[] expected3 = {(byte) 0x7F}; data = encodeByte((byte) 127); assertArrayEquals(expected3, data); }
### Question: BridgeStorageProvider { public Coin getLockingCap() { if (activations.isActive(RSKIP134)) { if (this.lockingCap == null) { this.lockingCap = safeGetFromRepository(LOCKING_CAP_KEY, BridgeSerializationUtils::deserializeCoin); } return this.lockingCap; } return null; } BridgeStorageProvider(Repository repository, RskAddress contractAddress, BridgeConstants bridgeConstants, ActivationConfig.ForBlock activations); List<UTXO> getNewFederationBtcUTXOs(); void saveNewFederationBtcUTXOs(); List<UTXO> getOldFederationBtcUTXOs(); void saveOldFederationBtcUTXOs(); Optional<Long> getHeightIfBtcTxhashIsAlreadyProcessed(Sha256Hash btcTxHash); void setHeightBtcTxhashAlreadyProcessed(Sha256Hash btcTxHash, long height); void saveHeightBtcTxHashAlreadyProcessed(); void saveBtcTxHashesAlreadyProcessed(); ReleaseRequestQueue getReleaseRequestQueue(); void saveReleaseRequestQueue(); ReleaseTransactionSet getReleaseTransactionSet(); void saveReleaseTransactionSet(); SortedMap<Keccak256, BtcTransaction> getRskTxsWaitingForSignatures(); void saveRskTxsWaitingForSignatures(); Federation getNewFederation(); void setNewFederation(Federation federation); void saveNewFederation(); Federation getOldFederation(); void setOldFederation(Federation federation); void saveOldFederation(); PendingFederation getPendingFederation(); void setPendingFederation(PendingFederation federation); void savePendingFederation(); void saveFederationElection(); ABICallElection getFederationElection(AddressBasedAuthorizer authorizer); void saveLockWhitelist(); LockWhitelist getLockWhitelist(); Coin getFeePerKb(); void setFeePerKb(Coin feePerKb); void saveFeePerKb(); void saveFeePerKbElection(); ABICallElection getFeePerKbElection(AddressBasedAuthorizer authorizer); void saveLockingCap(); void setLockingCap(Coin lockingCap); Coin getLockingCap(); CoinbaseInformation getCoinbaseInformation(Sha256Hash blockHash); void setCoinbaseInformation(Sha256Hash blockHash, CoinbaseInformation data); void save(); }### Answer: @Test public void getLockingCap_before_fork() { Repository repository = mock(Repository.class); when(repository.getStorageBytes(PrecompiledContracts.BRIDGE_ADDR, DataWord.fromString("lockingCap"))).thenReturn(new byte[] { 1 }); BridgeStorageProvider provider0 = new BridgeStorageProvider( repository, PrecompiledContracts.BRIDGE_ADDR, config.getNetworkConstants().getBridgeConstants(), activationsBeforeFork ); assertNull(provider0.getLockingCap()); verify(repository, never()).getStorageBytes(PrecompiledContracts.BRIDGE_ADDR, DataWord.fromString("lockingCap")); } @Test public void getLockingCap_after_fork() { Repository repository = mock(Repository.class); when(repository.getStorageBytes(PrecompiledContracts.BRIDGE_ADDR, DataWord.fromString("lockingCap"))).thenReturn(new byte[] { 1 }); BridgeStorageProvider provider0 = new BridgeStorageProvider( repository, PrecompiledContracts.BRIDGE_ADDR, config.getNetworkConstants().getBridgeConstants(), activationsAllForks ); assertEquals(Coin.SATOSHI, provider0.getLockingCap()); verify(repository, atLeastOnce()).getStorageBytes(PrecompiledContracts.BRIDGE_ADDR, DataWord.fromString("lockingCap")); }
### Question: RLP { public static byte[] encodeShort(short singleShort) { if ((singleShort & 0xFF) == singleShort) { return encodeByte((byte) singleShort); } else { return new byte[]{(byte) (OFFSET_SHORT_ITEM + 2), (byte) (singleShort >> 8 & 0xFF), (byte) (singleShort >> 0 & 0xFF)}; } } static int decodeInt(byte[] data, int index); static BigInteger decodeBigInteger(byte[] data, int index); static byte[] decodeIP4Bytes(byte[] data, int index); static int getFirstListElement(byte[] payload, int pos); static int getNextElementIndex(byte[] payload, int pos); static void fullTraverse(byte[] msgData, int level, int startPos, int endPos, int levelToIndex, Queue<Integer> index); @Nonnull static ArrayList<RLPElement> decode2(@CheckForNull byte[] msgData); static RLPElement decodeFirstElement(@CheckForNull byte[] msgData, int position); static RLPList decodeList(byte[] msgData); @Nullable static RLPElement decode2OneItem(@CheckForNull byte[] msgData, int startPos); @Nonnull static RskAddress parseRskAddress(@Nullable byte[] bytes); @Nonnull static Coin parseCoin(@Nullable byte[] bytes); @Nullable static Coin parseCoinNonNullZero(byte[] bytes); @Nullable static Coin parseSignedCoinNonNullZero(byte[] bytes); static Coin parseCoinNullZero(@Nullable byte[] bytes); @Nullable static BlockDifficulty parseBlockDifficulty(@Nullable byte[] bytes); static byte[] encode(Object input); static byte[] encodeLength(int length, int offset); static byte[] encodeByte(byte singleByte); static byte[] encodeShort(short singleShort); static byte[] encodeInt(int singleInt); static byte[] encodeString(String srcString); static byte[] encodeBigInteger(BigInteger srcBigInteger); static byte[] encodeRskAddress(RskAddress addr); static byte[] encodeCoin(@Nullable Coin coin); static byte[] encodeCoinNonNullZero(@CheckForNull Coin coin); static byte[] encodeSignedCoinNonNullZero(@CheckForNull Coin coin); static byte[] encodeCoinNullZero(Coin coin); static byte[] encodeBlockDifficulty(BlockDifficulty difficulty); static byte[] encodeElement(@Nullable byte[] srcData); static byte[] encodeListHeader(int size); static byte[] encodeSet(Set<ByteArrayWrapper> data); static byte[] encodeList(byte[]... elements); static byte[] encodedEmptyList(); static byte[] encodedEmptyByteArray(); }### Answer: @Test public void test5() { byte[] expected = {(byte) 0x80}; byte[] data = encodeShort((byte) 0); assertArrayEquals(expected, data); byte[] expected2 = {(byte) 0x78}; data = encodeShort((byte) 120); assertArrayEquals(expected2, data); byte[] expected3 = { (byte) 0x7F}; data = encodeShort((byte) 127); assertArrayEquals(expected3, data); byte[] expected4 = {(byte) 0x82, (byte) 0x76, (byte) 0x5F}; data = encodeShort((short) 30303); assertArrayEquals(expected4, data); byte[] expected5 = {(byte) 0x82, (byte) 0x4E, (byte) 0xEA}; data = encodeShort((short) 20202); assertArrayEquals(expected5, data); byte[] expected6 = {(byte) 0x82, (byte) 0x9D, (byte) 0x0A}; data = encodeShort((short) 40202); assertArrayEquals(expected6, data); }
### Question: BridgeStorageProvider { public void saveHeightBtcTxHashAlreadyProcessed() { if (btcTxHashesToSave == null) { return; } btcTxHashesToSave.forEach((btcTxHash, height) -> safeSaveToRepository(getStorageKeyForBtcTxHashAlreadyProcessed(btcTxHash), height, BridgeSerializationUtils::serializeLong) ); } BridgeStorageProvider(Repository repository, RskAddress contractAddress, BridgeConstants bridgeConstants, ActivationConfig.ForBlock activations); List<UTXO> getNewFederationBtcUTXOs(); void saveNewFederationBtcUTXOs(); List<UTXO> getOldFederationBtcUTXOs(); void saveOldFederationBtcUTXOs(); Optional<Long> getHeightIfBtcTxhashIsAlreadyProcessed(Sha256Hash btcTxHash); void setHeightBtcTxhashAlreadyProcessed(Sha256Hash btcTxHash, long height); void saveHeightBtcTxHashAlreadyProcessed(); void saveBtcTxHashesAlreadyProcessed(); ReleaseRequestQueue getReleaseRequestQueue(); void saveReleaseRequestQueue(); ReleaseTransactionSet getReleaseTransactionSet(); void saveReleaseTransactionSet(); SortedMap<Keccak256, BtcTransaction> getRskTxsWaitingForSignatures(); void saveRskTxsWaitingForSignatures(); Federation getNewFederation(); void setNewFederation(Federation federation); void saveNewFederation(); Federation getOldFederation(); void setOldFederation(Federation federation); void saveOldFederation(); PendingFederation getPendingFederation(); void setPendingFederation(PendingFederation federation); void savePendingFederation(); void saveFederationElection(); ABICallElection getFederationElection(AddressBasedAuthorizer authorizer); void saveLockWhitelist(); LockWhitelist getLockWhitelist(); Coin getFeePerKb(); void setFeePerKb(Coin feePerKb); void saveFeePerKb(); void saveFeePerKbElection(); ABICallElection getFeePerKbElection(AddressBasedAuthorizer authorizer); void saveLockingCap(); void setLockingCap(Coin lockingCap); Coin getLockingCap(); CoinbaseInformation getCoinbaseInformation(Sha256Hash blockHash); void setCoinbaseInformation(Sha256Hash blockHash, CoinbaseInformation data); void save(); }### Answer: @Test public void saveHeightBtcTxHashAlreadyProcessed() throws IOException { Repository repository = mock(Repository.class); Sha256Hash hash = Sha256Hash.ZERO_HASH; BridgeStorageProvider provider0 = new BridgeStorageProvider( repository, PrecompiledContracts.BRIDGE_ADDR, config.getNetworkConstants().getBridgeConstants(), activationsAllForks ); provider0.setHeightBtcTxhashAlreadyProcessed(hash, 1L); provider0.saveHeightBtcTxHashAlreadyProcessed(); verify(repository, never()).getStorageBytes(PrecompiledContracts.BRIDGE_ADDR, DataWord.fromString("btcTxHashesAP")); Optional<Long> result = provider0.getHeightIfBtcTxhashIsAlreadyProcessed(hash); assertTrue(result.isPresent()); assertEquals(Long.valueOf(1), result.get()); }
### Question: BridgeStorageProvider { public CoinbaseInformation getCoinbaseInformation(Sha256Hash blockHash) { if (!activations.isActive(RSKIP143)) { return null; } if (coinbaseInformationMap == null) { coinbaseInformationMap = new HashMap<>(); } if (coinbaseInformationMap.containsKey(blockHash)) { return coinbaseInformationMap.get(blockHash); } CoinbaseInformation coinbaseInformation = safeGetFromRepository(getStorageKeyForCoinbaseInformation(blockHash), BridgeSerializationUtils::deserializeCoinbaseInformation); coinbaseInformationMap.put(blockHash, coinbaseInformation); return coinbaseInformation; } BridgeStorageProvider(Repository repository, RskAddress contractAddress, BridgeConstants bridgeConstants, ActivationConfig.ForBlock activations); List<UTXO> getNewFederationBtcUTXOs(); void saveNewFederationBtcUTXOs(); List<UTXO> getOldFederationBtcUTXOs(); void saveOldFederationBtcUTXOs(); Optional<Long> getHeightIfBtcTxhashIsAlreadyProcessed(Sha256Hash btcTxHash); void setHeightBtcTxhashAlreadyProcessed(Sha256Hash btcTxHash, long height); void saveHeightBtcTxHashAlreadyProcessed(); void saveBtcTxHashesAlreadyProcessed(); ReleaseRequestQueue getReleaseRequestQueue(); void saveReleaseRequestQueue(); ReleaseTransactionSet getReleaseTransactionSet(); void saveReleaseTransactionSet(); SortedMap<Keccak256, BtcTransaction> getRskTxsWaitingForSignatures(); void saveRskTxsWaitingForSignatures(); Federation getNewFederation(); void setNewFederation(Federation federation); void saveNewFederation(); Federation getOldFederation(); void setOldFederation(Federation federation); void saveOldFederation(); PendingFederation getPendingFederation(); void setPendingFederation(PendingFederation federation); void savePendingFederation(); void saveFederationElection(); ABICallElection getFederationElection(AddressBasedAuthorizer authorizer); void saveLockWhitelist(); LockWhitelist getLockWhitelist(); Coin getFeePerKb(); void setFeePerKb(Coin feePerKb); void saveFeePerKb(); void saveFeePerKbElection(); ABICallElection getFeePerKbElection(AddressBasedAuthorizer authorizer); void saveLockingCap(); void setLockingCap(Coin lockingCap); Coin getLockingCap(); CoinbaseInformation getCoinbaseInformation(Sha256Hash blockHash); void setCoinbaseInformation(Sha256Hash blockHash, CoinbaseInformation data); void save(); }### Answer: @Test public void getCoinBaseInformation_before_RSKIP143() { Repository repository = mock(Repository.class); Sha256Hash hash = Sha256Hash.ZERO_HASH; BridgeStorageProvider provider = new BridgeStorageProvider( repository, PrecompiledContracts.BRIDGE_ADDR, config.getNetworkConstants().getBridgeConstants(), activationsBeforeFork ); CoinbaseInformation result = provider.getCoinbaseInformation(hash); assertNull(result); verify(repository, never()).getStorageBytes(PrecompiledContracts.BRIDGE_ADDR, DataWord.fromLongString("coinbaseInformation-" + hash.toString())); } @Test public void getCoinBaseInformation_after_RSKIP143() { Repository repository = mock(Repository.class); Sha256Hash hash = Sha256Hash.ZERO_HASH; CoinbaseInformation coinbaseInformation = new CoinbaseInformation(Sha256Hash.ZERO_HASH); when(repository.getStorageBytes(PrecompiledContracts.BRIDGE_ADDR, DataWord.fromLongString("coinbaseInformation-" + hash.toString()))) .thenReturn(BridgeSerializationUtils.serializeCoinbaseInformation(coinbaseInformation)); BridgeStorageProvider provider = new BridgeStorageProvider( repository, PrecompiledContracts.BRIDGE_ADDR, config.getNetworkConstants().getBridgeConstants(), activationsAllForks ); CoinbaseInformation result = provider.getCoinbaseInformation(hash); assertEquals(coinbaseInformation.getWitnessMerkleRoot(),result.getWitnessMerkleRoot()); }
### Question: Federation { public List<FederationMember> getMembers() { return members; } Federation(List<FederationMember> members, Instant creationTime, long creationBlockNumber, NetworkParameters btcParams); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); int getNumberOfSignaturesRequired(); Instant getCreationTime(); NetworkParameters getBtcParams(); long getCreationBlockNumber(); Script getRedeemScript(); Script getP2SHScript(); Address getAddress(); int getSize(); Integer getBtcPublicKeyIndex(BtcECKey key); boolean hasBtcPublicKey(BtcECKey key); boolean hasMemberWithRskAddress(byte[] address); boolean isMember(FederationMember federationMember); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); }### Answer: @Test public void membersImmutable() { boolean exception = false; try { federation.getMembers().add(new FederationMember(new BtcECKey(), new ECKey(), new ECKey())); } catch (Exception e) { exception = true; } Assert.assertTrue(exception); exception = false; try { federation.getMembers().remove(0); } catch (Exception e) { exception = true; } Assert.assertTrue(exception); }
### Question: Federation { public Integer getBtcPublicKeyIndex(BtcECKey key) { for (int i = 0; i < members.size(); i++) { if (Arrays.equals(key.getPubKey(), members.get(i).getBtcPublicKey().getPubKey())) { return i; } } return null; } Federation(List<FederationMember> members, Instant creationTime, long creationBlockNumber, NetworkParameters btcParams); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); int getNumberOfSignaturesRequired(); Instant getCreationTime(); NetworkParameters getBtcParams(); long getCreationBlockNumber(); Script getRedeemScript(); Script getP2SHScript(); Address getAddress(); int getSize(); Integer getBtcPublicKeyIndex(BtcECKey key); boolean hasBtcPublicKey(BtcECKey key); boolean hasMemberWithRskAddress(byte[] address); boolean isMember(FederationMember federationMember); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); }### Answer: @Test public void getBtcPublicKeyIndex() { for (int i = 0; i < federation.getBtcPublicKeys().size(); i++) { Assert.assertEquals(i, federation.getBtcPublicKeyIndex(sortedPublicKeys.get(i)).intValue()); } Assert.assertNull(federation.getBtcPublicKeyIndex(BtcECKey.fromPrivate(BigInteger.valueOf(1234)))); }
### Question: Federation { public boolean hasBtcPublicKey(BtcECKey key) { return getBtcPublicKeyIndex(key) != null; } Federation(List<FederationMember> members, Instant creationTime, long creationBlockNumber, NetworkParameters btcParams); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); int getNumberOfSignaturesRequired(); Instant getCreationTime(); NetworkParameters getBtcParams(); long getCreationBlockNumber(); Script getRedeemScript(); Script getP2SHScript(); Address getAddress(); int getSize(); Integer getBtcPublicKeyIndex(BtcECKey key); boolean hasBtcPublicKey(BtcECKey key); boolean hasMemberWithRskAddress(byte[] address); boolean isMember(FederationMember federationMember); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); }### Answer: @Test public void hasBtcPublicKey() { for (int i = 0; i < federation.getBtcPublicKeys().size(); i++) { Assert.assertTrue(federation.hasBtcPublicKey(sortedPublicKeys.get(i))); } Assert.assertFalse(federation.hasBtcPublicKey(BtcECKey.fromPrivate(BigInteger.valueOf(1234)))); }
### Question: Federation { public boolean hasMemberWithRskAddress(byte[] address) { return members.stream() .anyMatch(m -> Arrays.equals(m.getRskPublicKey().getAddress(), address)); } Federation(List<FederationMember> members, Instant creationTime, long creationBlockNumber, NetworkParameters btcParams); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); int getNumberOfSignaturesRequired(); Instant getCreationTime(); NetworkParameters getBtcParams(); long getCreationBlockNumber(); Script getRedeemScript(); Script getP2SHScript(); Address getAddress(); int getSize(); Integer getBtcPublicKeyIndex(BtcECKey key); boolean hasBtcPublicKey(BtcECKey key); boolean hasMemberWithRskAddress(byte[] address); boolean isMember(FederationMember federationMember); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); }### Answer: @Test public void hasMemberWithRskAddress() { for (int i = 0; i < federation.getBtcPublicKeys().size(); i++) { Assert.assertTrue(federation.hasMemberWithRskAddress(rskAddresses.get(i))); } byte[] nonFederateRskAddress = ECKey.fromPrivate(BigInteger.valueOf(1234)).getAddress(); Assert.assertFalse(federation.hasMemberWithRskAddress(nonFederateRskAddress)); }
### Question: Federation { @Override public String toString() { return String.format("%d of %d signatures federation", getNumberOfSignaturesRequired(), members.size()); } Federation(List<FederationMember> members, Instant creationTime, long creationBlockNumber, NetworkParameters btcParams); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); int getNumberOfSignaturesRequired(); Instant getCreationTime(); NetworkParameters getBtcParams(); long getCreationBlockNumber(); Script getRedeemScript(); Script getP2SHScript(); Address getAddress(); int getSize(); Integer getBtcPublicKeyIndex(BtcECKey key); boolean hasBtcPublicKey(BtcECKey key); boolean hasMemberWithRskAddress(byte[] address); boolean isMember(FederationMember federationMember); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); }### Answer: @Test public void testToString() { Assert.assertEquals("4 of 6 signatures federation", federation.toString()); }
### Question: Federation { public boolean isMember(FederationMember federationMember){ return this.members.contains(federationMember); } Federation(List<FederationMember> members, Instant creationTime, long creationBlockNumber, NetworkParameters btcParams); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); int getNumberOfSignaturesRequired(); Instant getCreationTime(); NetworkParameters getBtcParams(); long getCreationBlockNumber(); Script getRedeemScript(); Script getP2SHScript(); Address getAddress(); int getSize(); Integer getBtcPublicKeyIndex(BtcECKey key); boolean hasBtcPublicKey(BtcECKey key); boolean hasMemberWithRskAddress(byte[] address); boolean isMember(FederationMember federationMember); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); }### Answer: @Test public void isMember(){ FederationMember federationMember = federation.getMembers().get(0); Assert.assertTrue(federation.isMember(federationMember)); byte[] b = new byte[20]; new Random().nextBytes(b); ECKey invalidRskKey = ECKey.fromPrivate(b); BtcECKey invalidBtcKey = BtcECKey.fromPrivate(b); FederationMember invalidRskPubKey = new FederationMember(federationMember.getBtcPublicKey(), invalidRskKey, federationMember.getMstPublicKey()); Assert.assertFalse(federation.isMember(invalidRskPubKey)); FederationMember invalidBtcPubKey = new FederationMember(invalidBtcKey, federationMember.getRskPublicKey(), federationMember.getMstPublicKey()); Assert.assertFalse(federation.isMember(invalidBtcPubKey)); FederationMember invalidMstPubKey = new FederationMember(federationMember.getBtcPublicKey(), federationMember.getRskPublicKey(), invalidRskKey); Assert.assertFalse(federation.isMember(invalidMstPubKey)); FederationMember invalidPubKeys = new FederationMember(invalidBtcKey, invalidRskKey, invalidRskKey); Assert.assertFalse(federation.isMember(invalidPubKeys)); }
### Question: RLP { public static byte[] encodeBigInteger(BigInteger srcBigInteger) { if (srcBigInteger.equals(BigInteger.ZERO)) { return encodeByte((byte) 0); } else { return encodeElement(asUnsignedByteArray(srcBigInteger)); } } static int decodeInt(byte[] data, int index); static BigInteger decodeBigInteger(byte[] data, int index); static byte[] decodeIP4Bytes(byte[] data, int index); static int getFirstListElement(byte[] payload, int pos); static int getNextElementIndex(byte[] payload, int pos); static void fullTraverse(byte[] msgData, int level, int startPos, int endPos, int levelToIndex, Queue<Integer> index); @Nonnull static ArrayList<RLPElement> decode2(@CheckForNull byte[] msgData); static RLPElement decodeFirstElement(@CheckForNull byte[] msgData, int position); static RLPList decodeList(byte[] msgData); @Nullable static RLPElement decode2OneItem(@CheckForNull byte[] msgData, int startPos); @Nonnull static RskAddress parseRskAddress(@Nullable byte[] bytes); @Nonnull static Coin parseCoin(@Nullable byte[] bytes); @Nullable static Coin parseCoinNonNullZero(byte[] bytes); @Nullable static Coin parseSignedCoinNonNullZero(byte[] bytes); static Coin parseCoinNullZero(@Nullable byte[] bytes); @Nullable static BlockDifficulty parseBlockDifficulty(@Nullable byte[] bytes); static byte[] encode(Object input); static byte[] encodeLength(int length, int offset); static byte[] encodeByte(byte singleByte); static byte[] encodeShort(short singleShort); static byte[] encodeInt(int singleInt); static byte[] encodeString(String srcString); static byte[] encodeBigInteger(BigInteger srcBigInteger); static byte[] encodeRskAddress(RskAddress addr); static byte[] encodeCoin(@Nullable Coin coin); static byte[] encodeCoinNonNullZero(@CheckForNull Coin coin); static byte[] encodeSignedCoinNonNullZero(@CheckForNull Coin coin); static byte[] encodeCoinNullZero(Coin coin); static byte[] encodeBlockDifficulty(BlockDifficulty difficulty); static byte[] encodeElement(@Nullable byte[] srcData); static byte[] encodeListHeader(int size); static byte[] encodeSet(Set<ByteArrayWrapper> data); static byte[] encodeList(byte[]... elements); static byte[] encodedEmptyList(); static byte[] encodedEmptyByteArray(); }### Answer: @Test public void test6() { byte[] expected = new byte[]{(byte) 0x80}; byte[] data = encodeBigInteger(BigInteger.ZERO); assertArrayEquals(expected, data); } @Test public void testEncodeBigInteger() { BigInteger test = new BigInteger("100102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", 16); String expected = "a0100102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"; byte[] encoderesult = encode(test); assertEquals(expected, ByteUtil.toHexString(encoderesult)); byte[] decodeResult = decode2(encoderesult).get(0).getRLPData(); assertEquals(test, BigIntegers.fromUnsignedByteArray(decodeResult)); } @Test public void encodeBigIntegerEdge_1() { BigInteger integer = new BigInteger("80", 10); byte[] encodedData = encodeBigInteger(integer); System.out.println(ByteUtil.toHexString(encodedData)); }
### Question: BridgeUtils { public static boolean txIsProcessable(BtcLockSender.TxType txType, ActivationConfig.ForBlock activations) { return txType == BtcLockSender.TxType.P2PKH || activations.isActive(ConsensusRule.RSKIP143); } static Wallet getFederationNoSpendWallet(Context btcContext, Federation federation); static Wallet getFederationsNoSpendWallet(Context btcContext, List<Federation> federations); static Wallet getFederationSpendWallet(Context btcContext, Federation federation, List<UTXO> utxos); static Wallet getFederationsSpendWallet(Context btcContext, List<Federation> federations, List<UTXO> utxos); static boolean isValidLockTx(BtcTransaction tx); static Optional<Script> getFirstInputScriptSig(BtcTransaction tx); static boolean isLockTx(BtcTransaction tx, List<Federation> federations, Context btcContext, BridgeConstants bridgeConstants); static boolean isLockTx(BtcTransaction tx, Federation federation, Context btcContext, BridgeConstants bridgeConstants); static boolean txIsProcessable(BtcLockSender.TxType txType, ActivationConfig.ForBlock activations); static boolean isReleaseTx(BtcTransaction tx, List<Federation> federations); static boolean isMigrationTx(BtcTransaction btcTx, Federation activeFederation, Federation retiringFederation, Context btcContext, BridgeConstants bridgeConstants); static int countMissingSignatures(Context btcContext, BtcTransaction btcTx); static boolean hasEnoughSignatures(Context btcContext, BtcTransaction btcTx); static Address recoverBtcAddressFromEthTransaction(org.ethereum.core.Transaction tx, NetworkParameters networkParameters); static boolean isFreeBridgeTx(Transaction rskTx, Constants constants, ActivationConfig.ForBlock activations); static boolean isContractTx(Transaction rskTx); static boolean isFromFederateMember(org.ethereum.core.Transaction rskTx, Federation federation); static Coin getCoinFromBigInteger(BigInteger value); static boolean validateHeightAndConfirmations(int height, int btcBestChainHeight, int acceptableConfirmationsAmount, Sha256Hash btcTxHash); static Sha256Hash calculateMerkleRoot(NetworkParameters networkParameters, byte[] pmtSerialized, Sha256Hash btcTxHash); static void validateInputsCount(byte[] btcTxSerialized, boolean isActiveRskip); static boolean isInputSignedByThisFederator(BtcECKey federatorPublicKey, Sha256Hash sighash, TransactionInput input); }### Answer: @Test public void testTxIsProcessable() { ActivationConfig.ForBlock actForBlock = mock(ActivationConfig.ForBlock.class); when(actForBlock.isActive(ConsensusRule.RSKIP143)).thenReturn(false); assertTrue(BridgeUtils.txIsProcessable(BtcLockSender.TxType.P2PKH, actForBlock)); assertFalse(BridgeUtils.txIsProcessable(BtcLockSender.TxType.P2SHP2WPKH, actForBlock)); assertFalse(BridgeUtils.txIsProcessable(BtcLockSender.TxType.P2SHMULTISIG, actForBlock)); assertFalse(BridgeUtils.txIsProcessable(BtcLockSender.TxType.P2SHP2WSH, actForBlock)); when(actForBlock.isActive(ConsensusRule.RSKIP143)).thenReturn(true); assertTrue(BridgeUtils.txIsProcessable(BtcLockSender.TxType.P2PKH, actForBlock)); assertTrue(BridgeUtils.txIsProcessable(BtcLockSender.TxType.P2SHP2WPKH, actForBlock)); assertTrue(BridgeUtils.txIsProcessable(BtcLockSender.TxType.P2SHMULTISIG, actForBlock)); assertTrue(BridgeUtils.txIsProcessable(BtcLockSender.TxType.P2SHP2WSH, actForBlock)); }
### Question: BridgeUtils { public static Address recoverBtcAddressFromEthTransaction(org.ethereum.core.Transaction tx, NetworkParameters networkParameters) { org.ethereum.crypto.ECKey key = tx.getKey(); byte[] pubKey = key.getPubKey(true); return BtcECKey.fromPublicOnly(pubKey).toAddress(networkParameters); } static Wallet getFederationNoSpendWallet(Context btcContext, Federation federation); static Wallet getFederationsNoSpendWallet(Context btcContext, List<Federation> federations); static Wallet getFederationSpendWallet(Context btcContext, Federation federation, List<UTXO> utxos); static Wallet getFederationsSpendWallet(Context btcContext, List<Federation> federations, List<UTXO> utxos); static boolean isValidLockTx(BtcTransaction tx); static Optional<Script> getFirstInputScriptSig(BtcTransaction tx); static boolean isLockTx(BtcTransaction tx, List<Federation> federations, Context btcContext, BridgeConstants bridgeConstants); static boolean isLockTx(BtcTransaction tx, Federation federation, Context btcContext, BridgeConstants bridgeConstants); static boolean txIsProcessable(BtcLockSender.TxType txType, ActivationConfig.ForBlock activations); static boolean isReleaseTx(BtcTransaction tx, List<Federation> federations); static boolean isMigrationTx(BtcTransaction btcTx, Federation activeFederation, Federation retiringFederation, Context btcContext, BridgeConstants bridgeConstants); static int countMissingSignatures(Context btcContext, BtcTransaction btcTx); static boolean hasEnoughSignatures(Context btcContext, BtcTransaction btcTx); static Address recoverBtcAddressFromEthTransaction(org.ethereum.core.Transaction tx, NetworkParameters networkParameters); static boolean isFreeBridgeTx(Transaction rskTx, Constants constants, ActivationConfig.ForBlock activations); static boolean isContractTx(Transaction rskTx); static boolean isFromFederateMember(org.ethereum.core.Transaction rskTx, Federation federation); static Coin getCoinFromBigInteger(BigInteger value); static boolean validateHeightAndConfirmations(int height, int btcBestChainHeight, int acceptableConfirmationsAmount, Sha256Hash btcTxHash); static Sha256Hash calculateMerkleRoot(NetworkParameters networkParameters, byte[] pmtSerialized, Sha256Hash btcTxHash); static void validateInputsCount(byte[] btcTxSerialized, boolean isActiveRskip); static boolean isInputSignedByThisFederator(BtcECKey federatorPublicKey, Sha256Hash sighash, TransactionInput input); }### Answer: @Test public void getAddressFromEthTransaction() { org.ethereum.core.Transaction tx = new org.ethereum.core.Transaction(TO_ADDRESS, AMOUNT, NONCE, GAS_PRICE, GAS_LIMIT, DATA, constants.getChainId()); byte[] privKey = generatePrivKey(); tx.sign(privKey); Address expectedAddress = BtcECKey.fromPrivate(privKey).toAddress(RegTestParams.get()); Address result = BridgeUtils.recoverBtcAddressFromEthTransaction(tx, RegTestParams.get()); assertEquals(expectedAddress, result); } @Test(expected = Exception.class) public void getAddressFromEthNotSignTransaction() { org.ethereum.core.Transaction tx = new org.ethereum.core.Transaction(TO_ADDRESS, AMOUNT, NONCE, GAS_PRICE, GAS_LIMIT, DATA, constants.getChainId()); BridgeUtils.recoverBtcAddressFromEthTransaction(tx, RegTestParams.get()); }
### Question: BridgeUtils { public static Wallet getFederationNoSpendWallet(Context btcContext, Federation federation) { return getFederationsNoSpendWallet(btcContext, Collections.singletonList(federation)); } static Wallet getFederationNoSpendWallet(Context btcContext, Federation federation); static Wallet getFederationsNoSpendWallet(Context btcContext, List<Federation> federations); static Wallet getFederationSpendWallet(Context btcContext, Federation federation, List<UTXO> utxos); static Wallet getFederationsSpendWallet(Context btcContext, List<Federation> federations, List<UTXO> utxos); static boolean isValidLockTx(BtcTransaction tx); static Optional<Script> getFirstInputScriptSig(BtcTransaction tx); static boolean isLockTx(BtcTransaction tx, List<Federation> federations, Context btcContext, BridgeConstants bridgeConstants); static boolean isLockTx(BtcTransaction tx, Federation federation, Context btcContext, BridgeConstants bridgeConstants); static boolean txIsProcessable(BtcLockSender.TxType txType, ActivationConfig.ForBlock activations); static boolean isReleaseTx(BtcTransaction tx, List<Federation> federations); static boolean isMigrationTx(BtcTransaction btcTx, Federation activeFederation, Federation retiringFederation, Context btcContext, BridgeConstants bridgeConstants); static int countMissingSignatures(Context btcContext, BtcTransaction btcTx); static boolean hasEnoughSignatures(Context btcContext, BtcTransaction btcTx); static Address recoverBtcAddressFromEthTransaction(org.ethereum.core.Transaction tx, NetworkParameters networkParameters); static boolean isFreeBridgeTx(Transaction rskTx, Constants constants, ActivationConfig.ForBlock activations); static boolean isContractTx(Transaction rskTx); static boolean isFromFederateMember(org.ethereum.core.Transaction rskTx, Federation federation); static Coin getCoinFromBigInteger(BigInteger value); static boolean validateHeightAndConfirmations(int height, int btcBestChainHeight, int acceptableConfirmationsAmount, Sha256Hash btcTxHash); static Sha256Hash calculateMerkleRoot(NetworkParameters networkParameters, byte[] pmtSerialized, Sha256Hash btcTxHash); static void validateInputsCount(byte[] btcTxSerialized, boolean isActiveRskip); static boolean isInputSignedByThisFederator(BtcECKey federatorPublicKey, Sha256Hash sighash, TransactionInput input); }### Answer: @Test public void getFederationNoSpendWallet() { NetworkParameters regTestParameters = NetworkParameters.fromID(NetworkParameters.ID_REGTEST); Federation federation = new Federation(FederationTestUtils.getFederationMembersWithBtcKeys(Arrays.asList( BtcECKey.fromPublicOnly(Hex.decode("036bb9eab797eadc8b697f0e82a01d01cabbfaaca37e5bafc06fdc6fdd38af894a")), BtcECKey.fromPublicOnly(Hex.decode("031da807c71c2f303b7f409dd2605b297ac494a563be3b9ca5f52d95a43d183cc5")))), Instant.ofEpochMilli(5005L), 0L, regTestParameters); Context mockedBtcContext = mock(Context.class); when(mockedBtcContext.getParams()).thenReturn(regTestParameters); Wallet wallet = BridgeUtils.getFederationNoSpendWallet(mockedBtcContext, federation); Assert.assertEquals(BridgeBtcWallet.class, wallet.getClass()); assertIsWatching(federation.getAddress(), wallet, regTestParameters); }
### Question: BridgeUtils { private static boolean isReleaseTx(BtcTransaction tx, Federation federation) { return isReleaseTx(tx, Collections.singletonList(federation)); } static Wallet getFederationNoSpendWallet(Context btcContext, Federation federation); static Wallet getFederationsNoSpendWallet(Context btcContext, List<Federation> federations); static Wallet getFederationSpendWallet(Context btcContext, Federation federation, List<UTXO> utxos); static Wallet getFederationsSpendWallet(Context btcContext, List<Federation> federations, List<UTXO> utxos); static boolean isValidLockTx(BtcTransaction tx); static Optional<Script> getFirstInputScriptSig(BtcTransaction tx); static boolean isLockTx(BtcTransaction tx, List<Federation> federations, Context btcContext, BridgeConstants bridgeConstants); static boolean isLockTx(BtcTransaction tx, Federation federation, Context btcContext, BridgeConstants bridgeConstants); static boolean txIsProcessable(BtcLockSender.TxType txType, ActivationConfig.ForBlock activations); static boolean isReleaseTx(BtcTransaction tx, List<Federation> federations); static boolean isMigrationTx(BtcTransaction btcTx, Federation activeFederation, Federation retiringFederation, Context btcContext, BridgeConstants bridgeConstants); static int countMissingSignatures(Context btcContext, BtcTransaction btcTx); static boolean hasEnoughSignatures(Context btcContext, BtcTransaction btcTx); static Address recoverBtcAddressFromEthTransaction(org.ethereum.core.Transaction tx, NetworkParameters networkParameters); static boolean isFreeBridgeTx(Transaction rskTx, Constants constants, ActivationConfig.ForBlock activations); static boolean isContractTx(Transaction rskTx); static boolean isFromFederateMember(org.ethereum.core.Transaction rskTx, Federation federation); static Coin getCoinFromBigInteger(BigInteger value); static boolean validateHeightAndConfirmations(int height, int btcBestChainHeight, int acceptableConfirmationsAmount, Sha256Hash btcTxHash); static Sha256Hash calculateMerkleRoot(NetworkParameters networkParameters, byte[] pmtSerialized, Sha256Hash btcTxHash); static void validateInputsCount(byte[] btcTxSerialized, boolean isActiveRskip); static boolean isInputSignedByThisFederator(BtcECKey federatorPublicKey, Sha256Hash sighash, TransactionInput input); }### Answer: @Test public void testIsRelease() { NetworkParameters params = RegTestParams.get(); BridgeRegTestConstants bridgeConstants = BridgeRegTestConstants.getInstance(); Federation federation = bridgeConstants.getGenesisFederation(); List<BtcECKey> federationPrivateKeys = BridgeRegTestConstants.REGTEST_FEDERATION_PRIVATE_KEYS; Address randomAddress = new Address(params, Hex.decode("4a22c3c4cbb31e4d03b15550636762bda0baf85a")); BtcTransaction releaseTx1 = new BtcTransaction(params); releaseTx1.addOutput(Coin.COIN, randomAddress); TransactionInput releaseInput1 = new TransactionInput(params, releaseTx1, new byte[]{}, new TransactionOutPoint(params, 0, Sha256Hash.ZERO_HASH)); releaseTx1.addInput(releaseInput1); signWithNecessaryKeys(federation, federationPrivateKeys, releaseInput1, releaseTx1, bridgeConstants); assertThat(BridgeUtils.isReleaseTx(releaseTx1, Collections.singletonList(federation)), is(true)); BtcTransaction releaseTx2 = new BtcTransaction(params); releaseTx2.addOutput(Coin.COIN, randomAddress); TransactionInput releaseInput2 = new TransactionInput(params, releaseTx2, new byte[]{}, new TransactionOutPoint(params, 0, Sha256Hash.ZERO_HASH)); releaseTx2.addInput(releaseInput2); signWithNKeys(federation, federationPrivateKeys, releaseInput2, releaseTx2, bridgeConstants, 1); assertThat(BridgeUtils.isReleaseTx(releaseTx2, Collections.singletonList(federation)), is(false)); }
### Question: BridgeUtils { public static boolean isContractTx(Transaction rskTx) { return rskTx.getClass() == org.ethereum.vm.program.InternalTransaction.class; } static Wallet getFederationNoSpendWallet(Context btcContext, Federation federation); static Wallet getFederationsNoSpendWallet(Context btcContext, List<Federation> federations); static Wallet getFederationSpendWallet(Context btcContext, Federation federation, List<UTXO> utxos); static Wallet getFederationsSpendWallet(Context btcContext, List<Federation> federations, List<UTXO> utxos); static boolean isValidLockTx(BtcTransaction tx); static Optional<Script> getFirstInputScriptSig(BtcTransaction tx); static boolean isLockTx(BtcTransaction tx, List<Federation> federations, Context btcContext, BridgeConstants bridgeConstants); static boolean isLockTx(BtcTransaction tx, Federation federation, Context btcContext, BridgeConstants bridgeConstants); static boolean txIsProcessable(BtcLockSender.TxType txType, ActivationConfig.ForBlock activations); static boolean isReleaseTx(BtcTransaction tx, List<Federation> federations); static boolean isMigrationTx(BtcTransaction btcTx, Federation activeFederation, Federation retiringFederation, Context btcContext, BridgeConstants bridgeConstants); static int countMissingSignatures(Context btcContext, BtcTransaction btcTx); static boolean hasEnoughSignatures(Context btcContext, BtcTransaction btcTx); static Address recoverBtcAddressFromEthTransaction(org.ethereum.core.Transaction tx, NetworkParameters networkParameters); static boolean isFreeBridgeTx(Transaction rskTx, Constants constants, ActivationConfig.ForBlock activations); static boolean isContractTx(Transaction rskTx); static boolean isFromFederateMember(org.ethereum.core.Transaction rskTx, Federation federation); static Coin getCoinFromBigInteger(BigInteger value); static boolean validateHeightAndConfirmations(int height, int btcBestChainHeight, int acceptableConfirmationsAmount, Sha256Hash btcTxHash); static Sha256Hash calculateMerkleRoot(NetworkParameters networkParameters, byte[] pmtSerialized, Sha256Hash btcTxHash); static void validateInputsCount(byte[] btcTxSerialized, boolean isActiveRskip); static boolean isInputSignedByThisFederator(BtcECKey federatorPublicKey, Sha256Hash sighash, TransactionInput input); }### Answer: @Test public void testIsContractTx() { Assert.assertFalse(BridgeUtils.isContractTx(new Transaction((byte[]) null, null, null, null, null, null))); Assert.assertTrue(BridgeUtils.isContractTx(new org.ethereum.vm.program.InternalTransaction(null, 0, 0, null, null, null, null, null, null, null, null))); }
### Question: BridgeUtils { public static Coin getCoinFromBigInteger(BigInteger value) { if (value == null) { throw new BridgeIllegalArgumentException("value cannot be null"); } try { return Coin.valueOf(value.longValueExact()); } catch(ArithmeticException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } } static Wallet getFederationNoSpendWallet(Context btcContext, Federation federation); static Wallet getFederationsNoSpendWallet(Context btcContext, List<Federation> federations); static Wallet getFederationSpendWallet(Context btcContext, Federation federation, List<UTXO> utxos); static Wallet getFederationsSpendWallet(Context btcContext, List<Federation> federations, List<UTXO> utxos); static boolean isValidLockTx(BtcTransaction tx); static Optional<Script> getFirstInputScriptSig(BtcTransaction tx); static boolean isLockTx(BtcTransaction tx, List<Federation> federations, Context btcContext, BridgeConstants bridgeConstants); static boolean isLockTx(BtcTransaction tx, Federation federation, Context btcContext, BridgeConstants bridgeConstants); static boolean txIsProcessable(BtcLockSender.TxType txType, ActivationConfig.ForBlock activations); static boolean isReleaseTx(BtcTransaction tx, List<Federation> federations); static boolean isMigrationTx(BtcTransaction btcTx, Federation activeFederation, Federation retiringFederation, Context btcContext, BridgeConstants bridgeConstants); static int countMissingSignatures(Context btcContext, BtcTransaction btcTx); static boolean hasEnoughSignatures(Context btcContext, BtcTransaction btcTx); static Address recoverBtcAddressFromEthTransaction(org.ethereum.core.Transaction tx, NetworkParameters networkParameters); static boolean isFreeBridgeTx(Transaction rskTx, Constants constants, ActivationConfig.ForBlock activations); static boolean isContractTx(Transaction rskTx); static boolean isFromFederateMember(org.ethereum.core.Transaction rskTx, Federation federation); static Coin getCoinFromBigInteger(BigInteger value); static boolean validateHeightAndConfirmations(int height, int btcBestChainHeight, int acceptableConfirmationsAmount, Sha256Hash btcTxHash); static Sha256Hash calculateMerkleRoot(NetworkParameters networkParameters, byte[] pmtSerialized, Sha256Hash btcTxHash); static void validateInputsCount(byte[] btcTxSerialized, boolean isActiveRskip); static boolean isInputSignedByThisFederator(BtcECKey federatorPublicKey, Sha256Hash sighash, TransactionInput input); }### Answer: @Test(expected = BridgeIllegalArgumentException.class) public void getCoinFromBigInteger_bigger_than_long_value() { BridgeUtils.getCoinFromBigInteger(new BigInteger("9223372036854775808")); } @Test(expected = BridgeIllegalArgumentException.class) public void getCoinFromBigInteger_null_value() { BridgeUtils.getCoinFromBigInteger(null); } @Test public void getCoinFromBigInteger() { Assert.assertEquals(Coin.COIN, BridgeUtils.getCoinFromBigInteger(BigInteger.valueOf(Coin.COIN.getValue()))); }
### Question: BridgeUtils { public static boolean validateHeightAndConfirmations(int height, int btcBestChainHeight, int acceptableConfirmationsAmount, Sha256Hash btcTxHash) throws Exception { if (height < 0) { throw new Exception("Height can't be lower than 0"); } int confirmations = btcBestChainHeight - height + 1; if (confirmations < acceptableConfirmationsAmount) { logger.warn( "Btc Tx {} at least {} confirmations are required, but there are only {} confirmations", btcTxHash, acceptableConfirmationsAmount, confirmations ); return false; } return true; } static Wallet getFederationNoSpendWallet(Context btcContext, Federation federation); static Wallet getFederationsNoSpendWallet(Context btcContext, List<Federation> federations); static Wallet getFederationSpendWallet(Context btcContext, Federation federation, List<UTXO> utxos); static Wallet getFederationsSpendWallet(Context btcContext, List<Federation> federations, List<UTXO> utxos); static boolean isValidLockTx(BtcTransaction tx); static Optional<Script> getFirstInputScriptSig(BtcTransaction tx); static boolean isLockTx(BtcTransaction tx, List<Federation> federations, Context btcContext, BridgeConstants bridgeConstants); static boolean isLockTx(BtcTransaction tx, Federation federation, Context btcContext, BridgeConstants bridgeConstants); static boolean txIsProcessable(BtcLockSender.TxType txType, ActivationConfig.ForBlock activations); static boolean isReleaseTx(BtcTransaction tx, List<Federation> federations); static boolean isMigrationTx(BtcTransaction btcTx, Federation activeFederation, Federation retiringFederation, Context btcContext, BridgeConstants bridgeConstants); static int countMissingSignatures(Context btcContext, BtcTransaction btcTx); static boolean hasEnoughSignatures(Context btcContext, BtcTransaction btcTx); static Address recoverBtcAddressFromEthTransaction(org.ethereum.core.Transaction tx, NetworkParameters networkParameters); static boolean isFreeBridgeTx(Transaction rskTx, Constants constants, ActivationConfig.ForBlock activations); static boolean isContractTx(Transaction rskTx); static boolean isFromFederateMember(org.ethereum.core.Transaction rskTx, Federation federation); static Coin getCoinFromBigInteger(BigInteger value); static boolean validateHeightAndConfirmations(int height, int btcBestChainHeight, int acceptableConfirmationsAmount, Sha256Hash btcTxHash); static Sha256Hash calculateMerkleRoot(NetworkParameters networkParameters, byte[] pmtSerialized, Sha256Hash btcTxHash); static void validateInputsCount(byte[] btcTxSerialized, boolean isActiveRskip); static boolean isInputSignedByThisFederator(BtcECKey federatorPublicKey, Sha256Hash sighash, TransactionInput input); }### Answer: @Test(expected = Exception.class) public void validateHeightAndConfirmations_invalid_height() throws Exception { Assert.assertFalse(BridgeUtils.validateHeightAndConfirmations(-1, 0, 0, null)); } @Test public void validateHeightAndConfirmation_insufficient_confirmations() throws Exception { Assert.assertFalse(BridgeUtils.validateHeightAndConfirmations(2, 5, 10, Sha256Hash.of(Hex.decode("ab")))); } @Test public void validateHeightAndConfirmation_enough_confirmations() throws Exception { Assert.assertTrue(BridgeUtils.validateHeightAndConfirmations(2, 5, 3, Sha256Hash.of(Hex.decode("ab")))); }
### Question: BridgeUtils { public static void validateInputsCount(byte[] btcTxSerialized, boolean isActiveRskip) throws VerificationException.EmptyInputsOrOutputs { if (BtcTransactionFormatUtils.getInputsCount(btcTxSerialized) == 0) { if (isActiveRskip) { if (BtcTransactionFormatUtils.getInputsCountForSegwit(btcTxSerialized) == 0) { logger.warn("Provided btc segwit tx has no inputs"); throw new VerificationException.EmptyInputsOrOutputs(); } } else { logger.warn("Provided btc tx has no inputs "); throw new VerificationException.EmptyInputsOrOutputs(); } } } static Wallet getFederationNoSpendWallet(Context btcContext, Federation federation); static Wallet getFederationsNoSpendWallet(Context btcContext, List<Federation> federations); static Wallet getFederationSpendWallet(Context btcContext, Federation federation, List<UTXO> utxos); static Wallet getFederationsSpendWallet(Context btcContext, List<Federation> federations, List<UTXO> utxos); static boolean isValidLockTx(BtcTransaction tx); static Optional<Script> getFirstInputScriptSig(BtcTransaction tx); static boolean isLockTx(BtcTransaction tx, List<Federation> federations, Context btcContext, BridgeConstants bridgeConstants); static boolean isLockTx(BtcTransaction tx, Federation federation, Context btcContext, BridgeConstants bridgeConstants); static boolean txIsProcessable(BtcLockSender.TxType txType, ActivationConfig.ForBlock activations); static boolean isReleaseTx(BtcTransaction tx, List<Federation> federations); static boolean isMigrationTx(BtcTransaction btcTx, Federation activeFederation, Federation retiringFederation, Context btcContext, BridgeConstants bridgeConstants); static int countMissingSignatures(Context btcContext, BtcTransaction btcTx); static boolean hasEnoughSignatures(Context btcContext, BtcTransaction btcTx); static Address recoverBtcAddressFromEthTransaction(org.ethereum.core.Transaction tx, NetworkParameters networkParameters); static boolean isFreeBridgeTx(Transaction rskTx, Constants constants, ActivationConfig.ForBlock activations); static boolean isContractTx(Transaction rskTx); static boolean isFromFederateMember(org.ethereum.core.Transaction rskTx, Federation federation); static Coin getCoinFromBigInteger(BigInteger value); static boolean validateHeightAndConfirmations(int height, int btcBestChainHeight, int acceptableConfirmationsAmount, Sha256Hash btcTxHash); static Sha256Hash calculateMerkleRoot(NetworkParameters networkParameters, byte[] pmtSerialized, Sha256Hash btcTxHash); static void validateInputsCount(byte[] btcTxSerialized, boolean isActiveRskip); static boolean isInputSignedByThisFederator(BtcECKey federatorPublicKey, Sha256Hash sighash, TransactionInput input); }### Answer: @Test(expected = VerificationException.class) public void validateInputsCount_active_rskip() { BridgeUtils.validateInputsCount(Hex.decode("00000000000100"), true); } @Test(expected = VerificationException.class) public void validateInputsCount_inactive_rskip() { BridgeConstants bridgeConstants = BridgeRegTestConstants.getInstance(); NetworkParameters networkParameters = bridgeConstants.getBtcParams(); BtcTransaction tx = new BtcTransaction(networkParameters); BridgeUtils.validateInputsCount(tx.bitcoinSerialize(), false); }
### Question: MerkleTreeUtils { public static Sha256Hash combineLeftRight(Sha256Hash left, Sha256Hash right) { byte[] leftBytes = left.getBytes(); byte[] rightBytes = right.getBytes(); checkNotAValid64ByteTransaction(leftBytes, rightBytes); return Sha256Hash.wrapReversed( Sha256Hash.hashTwice( reverseBytes(leftBytes), 0, 32, reverseBytes(rightBytes), 0, 32 ) ); } private MerkleTreeUtils(); static Sha256Hash combineLeftRight(Sha256Hash left, Sha256Hash right); }### Answer: @Test public void combineLeftRight() { Assert.assertEquals( Sha256Hash.wrap("ceea4835dd23fae1978a3f6f3f0aa0171e018360272dd5b98d37550fbc978d01"), MerkleTreeUtils.combineLeftRight( Sha256Hash.wrap("b945b008fbc3f357db745909958b570773fc14575a36af8bbc195b484e21f366"), Sha256Hash.wrap("9880f57b6735152a8c6d4c7e1b3bc6434ee75e459511a642bbb8cb71d3a6b6d8") ) ); Assert.assertEquals( Sha256Hash.wrap("107857d7233c41d4c37ecaa9ad9d9ab15371f643074866cd23d657e6e99676be"), MerkleTreeUtils.combineLeftRight( Sha256Hash.wrap("083eafdf670bb1bbc83b63262887e3cf519c3e252fac29adfb92c1e857b37f91"), Sha256Hash.wrap("5740915e973a211c71655d10e4c672301c27c287843dcfa97b7aafc04992ec5e") ) ); Assert.assertEquals( Sha256Hash.wrap("71a12c9bd54735864dd6e12640e6d00d60a42a2e92e4cd0bde3f9f268b7d4345"), MerkleTreeUtils.combineLeftRight( Sha256Hash.wrap("c960ed36a67318cd562d384bfbf41499db1312835e2bfe86805d9465afe9736f"), Sha256Hash.wrap("120196be3b0ca6ba07d3cfee53f8dc883781e82afdfba11181184f41a67b9898") ) ); }
### Question: PartialMerkleTreeFormatUtils { public static VarInt getHashesCount(byte[] pmtSerialized) { return new VarInt(pmtSerialized, BLOCK_TRANSACTION_COUNT_LENGTH); } static VarInt getHashesCount(byte[] pmtSerialized); static VarInt getFlagBitsCount(byte[] pmtSerialized); static boolean hasExpectedSize(byte[] pmtSerialized); static Stream<Sha256Hash> streamIntermediateHashes(byte[] pmtSerialized); }### Answer: @Test public void getHashesCount() { String pmtSerializedEncoded = "030000000279e7c0da739df8a00f12c0bff55e5438f530aa5859ff9874258cd7bad3fe709746aff89" + "7e6a851faa80120d6ae99db30883699ac0428fc7192d6c3fec0ca6409010d"; byte[] pmtSerialized = Hex.decode(pmtSerializedEncoded); Assert.assertThat(PartialMerkleTreeFormatUtils.getHashesCount(pmtSerialized).value, is(2L)); }
### Question: PartialMerkleTreeFormatUtils { public static VarInt getFlagBitsCount(byte[] pmtSerialized) { VarInt hashesCount = getHashesCount(pmtSerialized); return new VarInt( pmtSerialized, Math.addExact( BLOCK_TRANSACTION_COUNT_LENGTH + hashesCount.getOriginalSizeInBytes(), Math.multiplyExact(Math.toIntExact(hashesCount.value), Sha256Hash.LENGTH) ) ); } static VarInt getHashesCount(byte[] pmtSerialized); static VarInt getFlagBitsCount(byte[] pmtSerialized); static boolean hasExpectedSize(byte[] pmtSerialized); static Stream<Sha256Hash> streamIntermediateHashes(byte[] pmtSerialized); }### Answer: @Test public void getFlagBitsCount() { String pmtSerializedEncoded = "030000000279e7c0da739df8a00f12c0bff55e5438f530aa5859ff9874258cd7bad3fe709746aff89" + "7e6a851faa80120d6ae99db30883699ac0428fc7192d6c3fec0ca6409010d"; byte[] pmtSerialized = Hex.decode(pmtSerializedEncoded); Assert.assertThat(PartialMerkleTreeFormatUtils.getFlagBitsCount(pmtSerialized).value, is(1L)); } @Test(expected = ArithmeticException.class) public void overflowSize() { String pmtSerializedEncoded = "0300ffffff79e7c0da739df8a00f12c0bff55e5438f530aa5859ff9874258cd7bad3fe709746aff89" + "7e6a851faa80120d6ae99db30883699ac0428fc7192d6c3fec0ca6409010d"; byte[] pmtSerialized = Hex.decode(pmtSerializedEncoded); PartialMerkleTreeFormatUtils.getFlagBitsCount(pmtSerialized); }
### Question: PartialMerkleTreeFormatUtils { public static boolean hasExpectedSize(byte[] pmtSerialized) { try { VarInt hashesCount = getHashesCount(pmtSerialized); VarInt flagBitsCount = getFlagBitsCount(pmtSerialized); int declaredSize = Math.addExact(Math.addExact(BLOCK_TRANSACTION_COUNT_LENGTH + hashesCount.getOriginalSizeInBytes() + flagBitsCount.getOriginalSizeInBytes(), Math.toIntExact(flagBitsCount.value)), Math.multiplyExact(Math.toIntExact(hashesCount.value), Sha256Hash.LENGTH) ); return pmtSerialized.length == declaredSize; } catch (RuntimeException e) { return false; } } static VarInt getHashesCount(byte[] pmtSerialized); static VarInt getFlagBitsCount(byte[] pmtSerialized); static boolean hasExpectedSize(byte[] pmtSerialized); static Stream<Sha256Hash> streamIntermediateHashes(byte[] pmtSerialized); }### Answer: @Test public void hasExpectedSize() { String pmtSerializedEncoded = "030000000279e7c0da739df8a00f12c0bff55e5438f530aa5859ff9874258cd7bad3fe709746aff89" + "7e6a851faa80120d6ae99db30883699ac0428fc7192d6c3fec0ca6409010d"; byte[] pmtSerialized = Hex.decode(pmtSerializedEncoded); Assert.assertThat(PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized), is(true)); } @Test public void doesntHaveExpectedSize() { String pmtSerializedEncoded = "030000000279e7c0da739df8a00f12c0bff55e5438f530aa5859ff9874258cd7bad3fe709746aff89" + "7e6a851faa80120d6ae99db30883699ac0428fc7192d6c3fec0ca64010d"; byte[] pmtSerialized = Hex.decode(pmtSerializedEncoded); Assert.assertThat(PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized), is(false)); }
### Question: BridgeEventLoggerImpl implements BridgeEventLogger { public void logUpdateCollections(Transaction rskTx) { if (activations.isActive(ConsensusRule.RSKIP146)) { logUpdateCollectionsInSolidityFormat(rskTx); } else { logUpdateCollectionsInRLPFormat(rskTx); } } BridgeEventLoggerImpl(BridgeConstants bridgeConstants, ActivationConfig.ForBlock activations, List<LogInfo> logs); void logUpdateCollections(Transaction rskTx); void logAddSignature(BtcECKey federatorPublicKey, BtcTransaction btcTx, byte[] rskTxHash); void logReleaseBtc(BtcTransaction btcTx, byte[] rskTxHash); void logCommitFederation(Block executionBlock, Federation oldFederation, Federation newFederation); void logLockBtc(RskAddress receiver, BtcTransaction btcTx, Address senderBtcAddress, Coin amount); void logReleaseBtcRequested(byte[] rskTransactionHash, BtcTransaction btcTx, Coin amount); }### Answer: @Test public void logUpdateCollectionsBeforeRskip146HardFork() { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); List<LogInfo> eventLogs = new LinkedList<>(); when(activations.isActive(ConsensusRule.RSKIP146)).thenReturn(false); BridgeEventLogger eventLogger = new BridgeEventLoggerImpl(null, activations, eventLogs); Transaction tx = mock(Transaction.class); RskAddress sender = mock(RskAddress.class); when(sender.toString()).thenReturn("0x0000000000000000000000000000000000000001"); when(tx.getSender()).thenReturn(sender); eventLogger.logUpdateCollections(tx); Assert.assertEquals(1, eventLogs.size()); LogInfo logResult = eventLogs.get(0); Assert.assertEquals(PrecompiledContracts.BRIDGE_ADDR, new RskAddress(logResult.getAddress())); Assert.assertEquals(1, logResult.getTopics().size()); List<DataWord> topics = Collections.singletonList(Bridge.UPDATE_COLLECTIONS_TOPIC); for (int i=0; i<topics.size(); i++) { Assert.assertEquals(topics.get(i), logResult.getTopics().get(i)); } byte[] encodedData = RLP.encodeElement(tx.getSender().getBytes()); Assert.assertArrayEquals(encodedData, logResult.getData()); } @Test public void logUpdateCollectionsAfterRskip146HardFork() { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); List<LogInfo> eventLogs = new LinkedList<>(); when(activations.isActive(ConsensusRule.RSKIP146)).thenReturn(true); BridgeEventLogger eventLogger = new BridgeEventLoggerImpl(null, activations, eventLogs); Transaction tx = mock(Transaction.class); RskAddress sender = mock(RskAddress.class); when(sender.toString()).thenReturn("0x0000000000000000000000000000000000000001"); when(tx.getSender()).thenReturn(sender); eventLogger.logUpdateCollections(tx); Assert.assertEquals(1, eventLogs.size()); LogInfo logResult = eventLogs.get(0); CallTransaction.Function event = BridgeEvents.UPDATE_COLLECTIONS.getEvent(); Assert.assertEquals(PrecompiledContracts.BRIDGE_ADDR, new RskAddress(logResult.getAddress())); Assert.assertEquals(1, logResult.getTopics().size()); byte[][] topics = event.encodeEventTopics(); for (int i=0; i<topics.length; i++) { Assert.assertArrayEquals(topics[i], logResult.getTopics().get(i).getData()); } byte[] encodedData = event.encodeEventData(tx.getSender().toString()); Assert.assertArrayEquals(encodedData, logResult.getData()); }
### Question: BridgeEventLoggerImpl implements BridgeEventLogger { public void logReleaseBtc(BtcTransaction btcTx, byte[] rskTxHash) { if (activations.isActive(ConsensusRule.RSKIP146)) { logReleaseBtcInSolidityFormat(btcTx, rskTxHash); } else { logReleaseBtcInRLPFormat(btcTx); } } BridgeEventLoggerImpl(BridgeConstants bridgeConstants, ActivationConfig.ForBlock activations, List<LogInfo> logs); void logUpdateCollections(Transaction rskTx); void logAddSignature(BtcECKey federatorPublicKey, BtcTransaction btcTx, byte[] rskTxHash); void logReleaseBtc(BtcTransaction btcTx, byte[] rskTxHash); void logCommitFederation(Block executionBlock, Federation oldFederation, Federation newFederation); void logLockBtc(RskAddress receiver, BtcTransaction btcTx, Address senderBtcAddress, Coin amount); void logReleaseBtcRequested(byte[] rskTransactionHash, BtcTransaction btcTx, Coin amount); }### Answer: @Test public void logReleaseBtcBeforeRskip146() { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); List<LogInfo> eventLogs = new LinkedList<>(); when(activations.isActive(ConsensusRule.RSKIP146)).thenReturn(false); BridgeEventLogger eventLogger = new BridgeEventLoggerImpl(null, activations, eventLogs); BtcTransaction btcTx = new BtcTransaction(BridgeRegTestConstants.getInstance().getBtcParams()); Keccak256 rskTxHash = PegTestUtils.createHash3(1); eventLogger.logReleaseBtc(btcTx, rskTxHash.getBytes()); Assert.assertEquals(1, eventLogs.size()); LogInfo logResult = eventLogs.get(0); Assert.assertEquals(PrecompiledContracts.BRIDGE_ADDR, new RskAddress(logResult.getAddress())); Assert.assertEquals(1, logResult.getTopics().size()); List<DataWord> topics = Collections.singletonList(Bridge.RELEASE_BTC_TOPIC); for (int i=0; i<topics.size(); i++) { Assert.assertEquals(topics.get(i), logResult.getTopics().get(i)); } byte[] encodedData = RLP.encodeList(RLP.encodeString(btcTx.getHashAsString()), RLP.encodeElement(btcTx.bitcoinSerialize())); Assert.assertArrayEquals(encodedData, logResult.getData()); } @Test public void logReleaseBtcAfterRskip146() { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); List<LogInfo> eventLogs = new LinkedList<>(); when(activations.isActive(ConsensusRule.RSKIP146)).thenReturn(true); BridgeEventLogger eventLogger = new BridgeEventLoggerImpl(null, activations, eventLogs); BtcTransaction btcTx = new BtcTransaction(BridgeRegTestConstants.getInstance().getBtcParams()); Keccak256 rskTxHash = PegTestUtils.createHash3(1); eventLogger.logReleaseBtc(btcTx, rskTxHash.getBytes()); Assert.assertEquals(1, eventLogs.size()); LogInfo logResult = eventLogs.get(0); CallTransaction.Function event = BridgeEvents.RELEASE_BTC.getEvent(); Assert.assertEquals(PrecompiledContracts.BRIDGE_ADDR, new RskAddress(logResult.getAddress())); Assert.assertEquals(2, logResult.getTopics().size()); byte[][] topics = event.encodeEventTopics(rskTxHash.getBytes()); for (int i=0; i<topics.length; i++) { Assert.assertArrayEquals(topics[i], logResult.getTopics().get(i).getData()); } byte[] encodedData = event.encodeEventData(btcTx.bitcoinSerialize()); Assert.assertArrayEquals(encodedData, logResult.getData()); }
### Question: BridgeEventLoggerImpl implements BridgeEventLogger { public void logReleaseBtcRequested(byte[] rskTransactionHash, BtcTransaction btcTx, Coin amount) { CallTransaction.Function event = BridgeEvents.RELEASE_REQUESTED.getEvent(); byte[][] encodedTopicsInBytes = event.encodeEventTopics(rskTransactionHash, btcTx.getHash().getBytes()); List<DataWord> encodedTopics = LogInfo.byteArrayToList(encodedTopicsInBytes); byte[] encodedData = event.encodeEventData(amount.getValue()); this.logs.add(new LogInfo(BRIDGE_CONTRACT_ADDRESS, encodedTopics, encodedData)); } BridgeEventLoggerImpl(BridgeConstants bridgeConstants, ActivationConfig.ForBlock activations, List<LogInfo> logs); void logUpdateCollections(Transaction rskTx); void logAddSignature(BtcECKey federatorPublicKey, BtcTransaction btcTx, byte[] rskTxHash); void logReleaseBtc(BtcTransaction btcTx, byte[] rskTxHash); void logCommitFederation(Block executionBlock, Federation oldFederation, Federation newFederation); void logLockBtc(RskAddress receiver, BtcTransaction btcTx, Address senderBtcAddress, Coin amount); void logReleaseBtcRequested(byte[] rskTransactionHash, BtcTransaction btcTx, Coin amount); }### Answer: @Test public void logReleaseBtcRequested() { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); List<LogInfo> eventLogs = new LinkedList<>(); when(activations.isActive(ConsensusRule.RSKIP146)).thenReturn(true); BridgeEventLogger eventLogger = new BridgeEventLoggerImpl(null, activations, eventLogs); Keccak256 rskTxHash = PegTestUtils.createHash3(0); BtcTransaction btcTx = new BtcTransaction(BridgeRegTestConstants.getInstance().getBtcParams()); Coin amount = Coin.SATOSHI; eventLogger.logReleaseBtcRequested(rskTxHash.getBytes(), btcTx, amount); Assert.assertEquals(1, eventLogs.size()); LogInfo entry = eventLogs.get(0); Assert.assertEquals(PrecompiledContracts.BRIDGE_ADDR, new RskAddress(entry.getAddress())); LogInfo result = eventLogs.get(0); Assert.assertArrayEquals(PrecompiledContracts.BRIDGE_ADDR.getBytes(), result.getAddress()); Assert.assertEquals(3, result.getTopics().size()); CallTransaction.Function event = BridgeEvents.RELEASE_REQUESTED.getEvent(); byte[][] topics = event.encodeEventTopics(rskTxHash.getBytes(), btcTx.getHash().getBytes()); for (int i=0; i<topics.length; i++) { Assert.assertArrayEquals(topics[i], result.getTopics().get(i).getData()); } Assert.assertArrayEquals(event.encodeEventData(amount.getValue()), result.getData()); }
### Question: ReleaseRequestQueue { public void add(Address destination, Coin amount, Keccak256 rskTxHash) { entries.add(new Entry(destination, amount, rskTxHash)); } ReleaseRequestQueue(List<Entry> entries); List<Entry> getEntriesWithoutHash(); List<Entry> getEntriesWithHash(); List<Entry> getEntries(); void add(Address destination, Coin amount, Keccak256 rskTxHash); void add(Address destination, Coin amount); void process(int maxIterations, Processor processor); }### Answer: @Test public void add() { Assert.assertFalse(queue.getEntries().contains(new ReleaseRequestQueue.Entry(mockAddress(10), Coin.valueOf(10)))); queue.add(mockAddress(10), Coin.valueOf(10), null); Assert.assertTrue(queue.getEntries().contains(new ReleaseRequestQueue.Entry(mockAddress(10), Coin.valueOf(10)))); }
### Question: ReleaseRequestQueue { public void process(int maxIterations, Processor processor) { ListIterator<Entry> iterator = entries.listIterator(); List<Entry> toRetry = new ArrayList<>(); int i = 0; while (iterator.hasNext() && i < maxIterations) { Entry entry = iterator.next(); iterator.remove(); ++i; if (!processor.process(entry)) { toRetry.add(entry); } } entries.addAll(toRetry); } ReleaseRequestQueue(List<Entry> entries); List<Entry> getEntriesWithoutHash(); List<Entry> getEntriesWithHash(); List<Entry> getEntries(); void add(Address destination, Coin amount, Keccak256 rskTxHash); void add(Address destination, Coin amount); void process(int maxIterations, Processor processor); }### Answer: @Test public void process() { class Indexer { public int index = 0; } Indexer idx = new Indexer(); queue.process(30, entry -> { assertEquals(entry, queueEntries.get(idx.index)); return idx.index++ % 2 == 0; }); assertEquals(5, idx.index); assertEquals(Arrays.asList( new ReleaseRequestQueue.Entry(mockAddress(5), Coin.COIN), new ReleaseRequestQueue.Entry(mockAddress(3), Coin.MILLICOIN) ), queue.getEntries()); }
### Question: P2shMultisigBtcLockSender implements BtcLockSender { public boolean tryParse(BtcTransaction btcTx) { if (btcTx == null) { return false; } if (btcTx.getInputs().size() == 0) { return false; } if (btcTx.getInput(0).getScriptBytes() == null) { return false; } Script scriptSig = btcTx.getInput(0).getScriptSig(); if (scriptSig.getChunks().size() < 3) { return false; } int chunksLength = scriptSig.getChunks().size(); byte[] redeemScript = scriptSig.getChunks().get(chunksLength - 1).data; Script redeem = new Script(redeemScript); if(!redeem.isSentToMultiSig()) { return false; } try { byte[] scriptPubKey = HashUtil.ripemd160(Sha256Hash.hash(redeemScript)); this.btcAddress = new Address(btcTx.getParams(), btcTx.getParams().getP2SHHeader(), scriptPubKey); } catch(Exception e) { return false; } return true; } P2shMultisigBtcLockSender(); BtcLockSender.TxType getType(); Address getBTCAddress(); RskAddress getRskAddress(); boolean tryParse(BtcTransaction btcTx); }### Answer: @Test public void doesnt_parse_if_transaction_is_null() { BtcLockSender btcLockSender = new P2shMultisigBtcLockSender(); Assert.assertFalse(btcLockSender.tryParse(null)); } @Test public void doesnt_parse_if_tx_doesnt_have_inputs() { BtcTransaction btcTx = new BtcTransaction(networkParameters); BtcLockSender btcLockSender = new P2shMultisigBtcLockSender(); Assert.assertFalse(btcLockSender.tryParse(btcTx)); } @Test public void doesnt_parse_if_tx_doesnt_have_scriptsig() { BtcTransaction btcTx = new BtcTransaction(networkParameters); btcTx.addInput(new TransactionInput(networkParameters, null, null)); BtcLockSender btcLockSender = new P2shMultisigBtcLockSender(); Assert.assertFalse(btcLockSender.tryParse(btcTx)); } @Test public void rejects_p2pkh_transaction() { String rawTx = RawTransactions.txs.get(BtcLockSender.TxType.P2PKH); BtcTransaction btcTx = new BtcTransaction(networkParameters, Hex.decode(rawTx)); BtcLockSender btcLockSender = new P2shMultisigBtcLockSender(); Assert.assertFalse(btcLockSender.tryParse(btcTx)); } @Test public void rejects_p2sh_p2wpkh_transaction() { String rawTx = RawTransactions.txs.get(BtcLockSender.TxType.P2SHP2WPKH); BtcTransaction btcTx = new BtcTransaction(networkParameters, Hex.decode(rawTx)); BtcLockSender btcLockSender = new P2shMultisigBtcLockSender(); Assert.assertFalse(btcLockSender.tryParse(btcTx)); } @Test public void rejects_p2sh_p2wsh_transaction() { String rawTx = RawTransactions.txs.get(BtcLockSender.TxType.P2SHP2WSH); BtcTransaction btcTx = new BtcTransaction(networkParameters, Hex.decode(rawTx)); BtcLockSender btcLockSender = new P2shMultisigBtcLockSender(); Assert.assertFalse(btcLockSender.tryParse(btcTx)); }
### Question: P2pkhBtcLockSender implements BtcLockSender { public boolean tryParse (BtcTransaction btcTx) { if (btcTx == null) { return false; } if (btcTx.getInputs().size() == 0) { return false; } if (btcTx.getInput(0).getScriptBytes() == null) { return false; } Script scriptSig = btcTx.getInput(0).getScriptSig(); if (scriptSig.getChunks().size() != 2) { return false; } try { byte[] data = scriptSig.getChunks().get(1).data; BtcECKey senderBtcKey = BtcECKey.fromPublicOnly(data); this.btcAddress = new Address(btcTx.getParams(), senderBtcKey.getPubKeyHash()); org.ethereum.crypto.ECKey key = org.ethereum.crypto.ECKey.fromPublicOnly(data); this.rskAddress = new RskAddress(key.getAddress()); } catch(Exception e) { return false; } return true; } P2pkhBtcLockSender(); BtcLockSender.TxType getType(); Address getBTCAddress(); RskAddress getRskAddress(); boolean tryParse(BtcTransaction btcTx); }### Answer: @Test public void doesnt_parse_if_tx_is_null() { BtcLockSender btcLockSender = new P2pkhBtcLockSender(); Assert.assertFalse(btcLockSender.tryParse(null)); } @Test public void doesnt_parse_if_tx_doesnt_have_inputs() { BtcTransaction btcTx = new BtcTransaction(networkParameters); BtcLockSender btcLockSender = new P2pkhBtcLockSender(); Assert.assertFalse(btcLockSender.tryParse(btcTx)); } @Test public void doesnt_parse_if_tx_doesnt_have_scriptsig() { BtcTransaction btcTx = new BtcTransaction(networkParameters); btcTx.addInput(new TransactionInput(networkParameters, null, null)); BtcLockSender btcLockSender = new P2pkhBtcLockSender(); Assert.assertFalse(btcLockSender.tryParse(btcTx)); } @Test public void doesnt_parse_if_tx_scriptsig_doesnt_have_two_chunks() { BtcTransaction btcTx = new BtcTransaction(networkParameters); btcTx.addInput(new TransactionInput(networkParameters, null, new byte[]{0x00})); BtcLockSender btcLockSender = new P2pkhBtcLockSender(); Assert.assertFalse(btcLockSender.tryParse(btcTx)); } @Test public void rejects_p2sh_p2wpkh_transaction() { String rawTx = RawTransactions.txs.get(BtcLockSender.TxType.P2SHP2WPKH); BtcTransaction btcTx = new BtcTransaction(networkParameters, Hex.decode(rawTx)); BtcLockSender btcLockSender = new P2pkhBtcLockSender(); Assert.assertFalse(btcLockSender.tryParse(btcTx)); } @Test public void rejects_p2sh_multisig_transaction() { String rawTx = RawTransactions.txs.get(BtcLockSender.TxType.P2SHMULTISIG); BtcTransaction btcTx = new BtcTransaction(networkParameters, Hex.decode(rawTx)); BtcLockSender btcLockSender = new P2pkhBtcLockSender(); Assert.assertFalse(btcLockSender.tryParse(btcTx)); } @Test public void rejects_p2sh_p2wsh_transaction() { String rawTx = RawTransactions.txs.get(BtcLockSender.TxType.P2SHP2WSH); BtcTransaction btcTx = new BtcTransaction(networkParameters, Hex.decode(rawTx)); BtcLockSender btcLockSender = new P2pkhBtcLockSender(); Assert.assertFalse(btcLockSender.tryParse(btcTx)); }
### Question: RepositoryBtcBlockStoreWithCache implements BtcBlockStoreWithCache { @Override public synchronized StoredBlock getChainHead() { byte[] ba = repository.getStorageBytes(contractAddress, DataWord.fromString(BLOCK_STORE_CHAIN_HEAD_KEY)); if (ba == null) { return null; } return byteArrayToStoredBlock(ba); } RepositoryBtcBlockStoreWithCache(NetworkParameters btcNetworkParams, Repository repository, Map<Sha256Hash, StoredBlock> cacheBlocks, RskAddress contractAddress); @Override synchronized void put(StoredBlock storedBlock); @Override synchronized StoredBlock get(Sha256Hash hash); @Override synchronized StoredBlock getChainHead(); @Override synchronized void setChainHead(StoredBlock newChainHead); @Override void close(); @Override NetworkParameters getParams(); @Override StoredBlock getFromCache(Sha256Hash branchBlockHash); @Override StoredBlock getStoredBlockAtMainChainHeight(int height); @Override StoredBlock getStoredBlockAtMainChainDepth(int depth); static final String BLOCK_STORE_CHAIN_HEAD_KEY; static final int MAX_DEPTH_STORED_BLOCKS; static final int MAX_SIZE_MAP_STORED_BLOCKS; }### Answer: @Test public void getChainHead_Test() throws BlockStoreException { BtcBlockStoreWithCache btcBlockStore = createBlockStore(); assertEquals(networkParameters.getGenesisBlock(), btcBlockStore.getChainHead().getHeader()); }
### Question: RepositoryBtcBlockStoreWithCache implements BtcBlockStoreWithCache { @Override public NetworkParameters getParams() { return btcNetworkParams; } RepositoryBtcBlockStoreWithCache(NetworkParameters btcNetworkParams, Repository repository, Map<Sha256Hash, StoredBlock> cacheBlocks, RskAddress contractAddress); @Override synchronized void put(StoredBlock storedBlock); @Override synchronized StoredBlock get(Sha256Hash hash); @Override synchronized StoredBlock getChainHead(); @Override synchronized void setChainHead(StoredBlock newChainHead); @Override void close(); @Override NetworkParameters getParams(); @Override StoredBlock getFromCache(Sha256Hash branchBlockHash); @Override StoredBlock getStoredBlockAtMainChainHeight(int height); @Override StoredBlock getStoredBlockAtMainChainDepth(int depth); static final String BLOCK_STORE_CHAIN_HEAD_KEY; static final int MAX_DEPTH_STORED_BLOCKS; static final int MAX_SIZE_MAP_STORED_BLOCKS; }### Answer: @Test public void getParams_Test() { BtcBlockStoreWithCache btcBlockStore = createBlockStore(); assertEquals(networkParameters, btcBlockStore.getParams()); }
### Question: FederationSupport { public Federation getActiveFederation() { switch (getActiveFederationReference()) { case NEW: return provider.getNewFederation(); case OLD: return provider.getOldFederation(); case GENESIS: default: return bridgeConstants.getGenesisFederation(); } } FederationSupport(BridgeConstants bridgeConstants, BridgeStorageProvider provider, Block executionBlock); int getFederationSize(); byte[] getFederatorBtcPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); byte[] getMemberPublicKeyOfType(List<FederationMember> members, int index, FederationMember.KeyType keyType, String errorPrefix); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); List<UTXO> getActiveFederationBtcUTXOs(); List<UTXO> getRetiringFederationBtcUTXOs(); boolean amAwaitingFederationActivation(); }### Answer: @Test public void whenNewFederationIsNullThenActiveFederationIsGenesisFederation() { Federation genesisFederation = getNewFakeFederation(0); when(provider.getNewFederation()) .thenReturn(null); when(bridgeConstants.getGenesisFederation()) .thenReturn(genesisFederation); assertThat(federationSupport.getActiveFederation(), is(genesisFederation)); } @Test public void whenOldFederationIsNullThenActiveFederationIsNewFederation() { Federation newFederation = getNewFakeFederation(100); when(provider.getNewFederation()) .thenReturn(newFederation); when(provider.getOldFederation()) .thenReturn(null); assertThat(federationSupport.getActiveFederation(), is(newFederation)); } @Test public void whenOldAndNewFederationArePresentReturnOldFederationByActivationAge() { Federation newFederation = getNewFakeFederation(75); Federation oldFederation = getNewFakeFederation(0); when(provider.getNewFederation()) .thenReturn(newFederation); when(provider.getOldFederation()) .thenReturn(oldFederation); when(executionBlock.getNumber()) .thenReturn(80L); when(bridgeConstants.getFederationActivationAge()) .thenReturn(10L); assertThat(federationSupport.getActiveFederation(), is(oldFederation)); } @Test public void whenOldAndNewFederationArePresentReturnNewFederationByActivationAge() { Federation newFederation = getNewFakeFederation(65); Federation oldFederation = getNewFakeFederation(0); when(provider.getNewFederation()) .thenReturn(newFederation); when(provider.getOldFederation()) .thenReturn(oldFederation); when(executionBlock.getNumber()) .thenReturn(80L); when(bridgeConstants.getFederationActivationAge()) .thenReturn(10L); assertThat(federationSupport.getActiveFederation(), is(newFederation)); }
### Question: FederationSupport { public byte[] getMemberPublicKeyOfType(List<FederationMember> members, int index, FederationMember.KeyType keyType, String errorPrefix) { if (index < 0 || index >= members.size()) { throw new IndexOutOfBoundsException(String.format("%s index must be between 0 and %d", errorPrefix, members.size() - 1)); } return members.get(index).getPublicKey(keyType).getPubKey(true); } FederationSupport(BridgeConstants bridgeConstants, BridgeStorageProvider provider, Block executionBlock); int getFederationSize(); byte[] getFederatorBtcPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); byte[] getMemberPublicKeyOfType(List<FederationMember> members, int index, FederationMember.KeyType keyType, String errorPrefix); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); List<UTXO> getActiveFederationBtcUTXOs(); List<UTXO> getRetiringFederationBtcUTXOs(); boolean amAwaitingFederationActivation(); }### Answer: @Test public void getMemberPublicKeyOfType() { BtcECKey btcKey0 = new BtcECKey(); ECKey rskKey0 = new ECKey(); ECKey mstKey0 = new ECKey(); BtcECKey btcKey1 = new BtcECKey(); ECKey rskKey1 = new ECKey(); ECKey mstKey1 = new ECKey(); List<FederationMember> members = Arrays.asList( new FederationMember(btcKey0, rskKey0, mstKey0), new FederationMember(btcKey1, rskKey1, mstKey1) ); Assert.assertTrue(Arrays.equals(federationSupport.getMemberPublicKeyOfType(members, 0, FederationMember.KeyType.BTC, "a prefix"), btcKey0.getPubKey())); Assert.assertTrue(Arrays.equals(federationSupport.getMemberPublicKeyOfType(members, 1, FederationMember.KeyType.BTC, "a prefix"), btcKey1.getPubKey())); Assert.assertTrue(Arrays.equals(federationSupport.getMemberPublicKeyOfType(members, 0, FederationMember.KeyType.RSK, "a prefix"), rskKey0.getPubKey(true))); Assert.assertTrue(Arrays.equals(federationSupport.getMemberPublicKeyOfType(members, 1, FederationMember.KeyType.RSK, "a prefix"), rskKey1.getPubKey(true))); Assert.assertTrue(Arrays.equals(federationSupport.getMemberPublicKeyOfType(members, 0, FederationMember.KeyType.MST, "a prefix"), mstKey0.getPubKey(true))); Assert.assertTrue(Arrays.equals(federationSupport.getMemberPublicKeyOfType(members, 1, FederationMember.KeyType.MST, "a prefix"), mstKey1.getPubKey(true))); } @Test public void getMemberPublicKeyOfType_OutOfBounds() { List<FederationMember> members = Arrays.asList( new FederationMember(new BtcECKey(), new ECKey(), new ECKey()), new FederationMember(new BtcECKey(), new ECKey(), new ECKey()) ); try { federationSupport.getMemberPublicKeyOfType(members,2, FederationMember.KeyType.BTC, "a prefix"); Assert.fail(); } catch (IndexOutOfBoundsException e) { Assert.assertTrue(e.getMessage().startsWith("a prefix")); } try { federationSupport.getMemberPublicKeyOfType(members,-1, FederationMember.KeyType.MST, "another prefix"); Assert.fail(); } catch (IndexOutOfBoundsException e) { Assert.assertTrue(e.getMessage().startsWith("another prefix")); } }
### Question: FederationMember { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } FederationMember otherFederationMember = (FederationMember) other; return Arrays.equals(btcPublicKey.getPubKey(), otherFederationMember.btcPublicKey.getPubKey()) && Arrays.equals(rskPublicKey.getPubKey(), otherFederationMember.rskPublicKey.getPubKey()) && Arrays.equals(mstPublicKey.getPubKey(), otherFederationMember.mstPublicKey.getPubKey()); } FederationMember(BtcECKey btcPublicKey, ECKey rskPublicKey, ECKey mstPublicKey); static FederationMember getFederationMemberFromKey(BtcECKey pk); static List<FederationMember> getFederationMembersFromKeys(List<BtcECKey> pks); BtcECKey getBtcPublicKey(); ECKey getRskPublicKey(); ECKey getMstPublicKey(); ECKey getPublicKey(KeyType keyType); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); static final Comparator<FederationMember> BTC_RSK_MST_PUBKEYS_COMPARATOR; }### Answer: @Test public void testEquals_basic() { Assert.assertTrue(member.equals(member)); Assert.assertFalse(member.equals(null)); Assert.assertFalse(member.equals(new Object())); Assert.assertFalse(member.equals("something else")); } @Test public void testEquals_sameKeys() { FederationMember otherMember = new FederationMember(btcKey, rskKey, mstKey); Assert.assertTrue(member.equals(otherMember)); } @Test public void testEquals_sameKeysDifferentCompression() { FederationMember uncompressedMember = new FederationMember( BtcECKey.fromPublicOnly(btcKey.getPubKeyPoint().getEncoded(false)), ECKey.fromPublicOnly(rskKey.getPubKey(false)), ECKey.fromPublicOnly(mstKey.getPubKey(false)) ); FederationMember compressedMember = new FederationMember( BtcECKey.fromPublicOnly(btcKey.getPubKeyPoint().getEncoded(true)), ECKey.fromPublicOnly(rskKey.getPubKey(true)), ECKey.fromPublicOnly(mstKey.getPubKey(true)) ); Assert.assertTrue(compressedMember.equals(uncompressedMember)); Assert.assertTrue(uncompressedMember.equals(compressedMember)); } @Test public void testEquals_differentBtcKey() { FederationMember otherMember = new FederationMember(new BtcECKey(), rskKey, mstKey); Assert.assertFalse(member.equals(otherMember)); } @Test public void testEquals_differentRskKey() { FederationMember otherMember = new FederationMember(btcKey, new ECKey(), mstKey); Assert.assertFalse(member.equals(otherMember)); } @Test public void testEquals_differentMstKey() { FederationMember otherMember = new FederationMember(btcKey, rskKey, new ECKey()); Assert.assertFalse(member.equals(otherMember)); }
### Question: RemascFeesPayer { public void payMiningFees(byte[] blockHash, Coin value, RskAddress toAddress, List<LogInfo> logs) { this.transferPayment(value, toAddress); this.logPayment(blockHash, value, toAddress, logs); } RemascFeesPayer(Repository repository, RskAddress contractAddress); List<ProgramSubtrace> getSubtraces(); void payMiningFees(byte[] blockHash, Coin value, RskAddress toAddress, List<LogInfo> logs); }### Answer: @Test public void payMiningFees() { Repository repositoryMock = Mockito.mock(Repository.class); RemascFeesPayer feesPayer = new RemascFeesPayer(repositoryMock, PrecompiledContracts.REMASC_ADDR); byte[] blockHash = { 0x1, 0x2 }; Coin value = Coin.valueOf(7L); RskAddress toAddress = new RskAddress("6c386a4b26f73c802f34673f7248bb118f97424a"); List<LogInfo> logs = new ArrayList<>(); feesPayer.payMiningFees(blockHash, value, toAddress, logs); Assert.assertEquals(1, feesPayer.getSubtraces().size()); ProgramSubtrace subtrace = feesPayer.getSubtraces().get(0); Assert.assertEquals(DataWord.valueOf(PrecompiledContracts.REMASC_ADDR.getBytes()), subtrace.getInvokeData().getCallerAddress()); Assert.assertEquals(DataWord.valueOf(toAddress.getBytes()), subtrace.getInvokeData().getOwnerAddress()); Assert.assertEquals(DataWord.valueOf(value.getBytes()), subtrace.getInvokeData().getCallValue()); Assert.assertEquals(1, logs.size()); LogInfo result = logs.get(0); Assert.assertArrayEquals(PrecompiledContracts.REMASC_ADDR.getBytes(), result.getAddress()); Assert.assertEquals(2, result.getTopics().size()); Assert.assertEquals("000000000000000000000000000000006d696e696e675f6665655f746f706963", result.getTopics().get(0).toString()); Assert.assertEquals("0000000000000000000000006c386a4b26f73c802f34673f7248bb118f97424a", result.getTopics().get(1).toString()); Assert.assertNotNull(result.getData()); List<RLPElement> rlpData = RLP.decode2(result.getData()); Assert.assertEquals(1 , rlpData.size()); RLPList dataList = (RLPList)rlpData.get(0); Assert.assertEquals(2, dataList.size()); Assert.assertArrayEquals(blockHash, dataList.get(0).getRLPData()); Assert.assertEquals(value, RLP.parseCoin(dataList.get(1).getRLPData())); verify(repositoryMock, times(1)).addBalance(PrecompiledContracts.REMASC_ADDR, value.negate()); verify(repositoryMock, times(1)).addBalance(toAddress, value); }
### Question: RemascStorageProvider { public Coin getRewardBalance() { if (rewardBalance != null) { return rewardBalance; } DataWord address = DataWord.fromString(REWARD_BALANCE_KEY); DataWord value = this.repository.getStorageValue(this.contractAddress, address); if (value == null) { return Coin.ZERO; } return new Coin(value.getData()); } RemascStorageProvider(Repository repository, RskAddress contractAddress); Coin getFederationBalance(); Coin getRewardBalance(); void setFederationBalance(Coin federationBalance); void setRewardBalance(Coin rewardBalance); Coin getBurnedBalance(); void setBurnedBalance(Coin burnedBalance); void addToBurnBalance(Coin amountToBurn); Boolean getBrokenSelectionRule(); void setBrokenSelectionRule(Boolean brokenSelectionRule); void save(); }### Answer: @Test public void getDefautRewardBalance() { RskAddress accountAddress = randomAddress(); Repository repository = createRepository(); RemascStorageProvider provider = new RemascStorageProvider(repository, accountAddress); Assert.assertEquals(Coin.ZERO, provider.getRewardBalance()); }
### Question: RemascStorageProvider { public Coin getBurnedBalance() { if (burnedBalance != null) { return burnedBalance; } DataWord address = DataWord.fromString(BURNED_BALANCE_KEY); DataWord value = this.repository.getStorageValue(this.contractAddress, address); if (value == null) { return Coin.ZERO; } return new Coin(value.getData()); } RemascStorageProvider(Repository repository, RskAddress contractAddress); Coin getFederationBalance(); Coin getRewardBalance(); void setFederationBalance(Coin federationBalance); void setRewardBalance(Coin rewardBalance); Coin getBurnedBalance(); void setBurnedBalance(Coin burnedBalance); void addToBurnBalance(Coin amountToBurn); Boolean getBrokenSelectionRule(); void setBrokenSelectionRule(Boolean brokenSelectionRule); void save(); }### Answer: @Test public void getDefautBurnedBalance() { RskAddress accountAddress = randomAddress(); Repository repository = createRepository(); RemascStorageProvider provider = new RemascStorageProvider(repository, accountAddress); Assert.assertEquals(Coin.ZERO, provider.getBurnedBalance()); }
### Question: RemascStorageProvider { public Boolean getBrokenSelectionRule() { if (brokenSelectionRule!= null) { return brokenSelectionRule; } DataWord address = DataWord.fromString(BROKEN_SELECTION_RULE_KEY); byte[] bytes = this.repository.getStorageBytes(this.contractAddress, address); if (bytes == null || bytes.length == 0) { return Boolean.FALSE; } if (bytes[0] == 0) { return Boolean.FALSE; } else { return Boolean.TRUE; } } RemascStorageProvider(Repository repository, RskAddress contractAddress); Coin getFederationBalance(); Coin getRewardBalance(); void setFederationBalance(Coin federationBalance); void setRewardBalance(Coin rewardBalance); Coin getBurnedBalance(); void setBurnedBalance(Coin burnedBalance); void addToBurnBalance(Coin amountToBurn); Boolean getBrokenSelectionRule(); void setBrokenSelectionRule(Boolean brokenSelectionRule); void save(); }### Answer: @Test public void getDefaultBrokenSelectionRule() { RskAddress accountAddress = randomAddress(); Repository repository = createRepository(); RemascStorageProvider provider = new RemascStorageProvider(repository, accountAddress); Assert.assertEquals(Boolean.FALSE, provider.getBrokenSelectionRule()); }
### Question: RemascFederationProvider { public int getFederationSize() { return this.federationSupport.getFederationSize(); } RemascFederationProvider( ActivationConfig activationConfig, BridgeConstants bridgeConstants, Repository repository, Block processingBlock); int getFederationSize(); RskAddress getFederatorAddress(int n); }### Answer: @Test public void getDefaultFederationSize() { RemascFederationProvider provider = getRemascFederationProvider(); Assert.assertEquals(3, provider.getFederationSize()); }
### Question: RemascFederationProvider { public RskAddress getFederatorAddress(int n) { byte[] publicKey = this.federationSupport.getFederatorBtcPublicKey(n); return new RskAddress(ECKey.fromPublicOnly(publicKey).getAddress()); } RemascFederationProvider( ActivationConfig activationConfig, BridgeConstants bridgeConstants, Repository repository, Block processingBlock); int getFederationSize(); RskAddress getFederatorAddress(int n); }### Answer: @Test public void getFederatorAddress() { RemascFederationProvider provider = getRemascFederationProvider(); byte[] address = provider.getFederatorAddress(0).getBytes(); Assert.assertNotNull(address); Assert.assertEquals(20, address.length); }
### Question: BlockDifficulty implements Comparable<BlockDifficulty>, Serializable { public BlockDifficulty add(BlockDifficulty other) { return new BlockDifficulty(value.add(other.value)); } BlockDifficulty(BigInteger value); byte[] getBytes(); BigInteger asBigInteger(); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); BlockDifficulty add(BlockDifficulty other); BlockDifficulty subtract(BlockDifficulty other); @Override int compareTo(@Nonnull BlockDifficulty other); static final BlockDifficulty ZERO; static final BlockDifficulty ONE; }### Answer: @Test public void addOneToZero() { BlockDifficulty d1 = new BlockDifficulty(BigInteger.ZERO); BlockDifficulty d2 = new BlockDifficulty(BigInteger.ONE); assertThat(d1.add(d2), is(d2)); } @Test public void addOneToOne() { BlockDifficulty d1 = new BlockDifficulty(BigInteger.ONE); BlockDifficulty d2 = new BlockDifficulty(BigInteger.ONE); assertThat(d1.add(d2), is(new BlockDifficulty(BigInteger.valueOf(2)))); } @Test public void addLargeValues() { BlockDifficulty d1 = new BlockDifficulty(BigInteger.valueOf(Long.MAX_VALUE)); BlockDifficulty d2 = new BlockDifficulty(BigInteger.valueOf(Integer.MAX_VALUE)); assertThat(d1.add(d2), is(new BlockDifficulty(new BigInteger("9223372039002259454")))); }
### Question: BlockDifficulty implements Comparable<BlockDifficulty>, Serializable { @Override public int compareTo(@Nonnull BlockDifficulty other) { return value.compareTo(other.value); } BlockDifficulty(BigInteger value); byte[] getBytes(); BigInteger asBigInteger(); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); BlockDifficulty add(BlockDifficulty other); BlockDifficulty subtract(BlockDifficulty other); @Override int compareTo(@Nonnull BlockDifficulty other); static final BlockDifficulty ZERO; static final BlockDifficulty ONE; }### Answer: @Test public void testComparable() { BlockDifficulty zero = BlockDifficulty.ZERO; BlockDifficulty d1 = new BlockDifficulty(BigInteger.valueOf(Long.MAX_VALUE)); BlockDifficulty d2 = new BlockDifficulty(BigInteger.valueOf(Integer.MAX_VALUE)); assertThat(zero.compareTo(zero), is(0)); assertThat(d1.compareTo(d1), is(0)); assertThat(d2.compareTo(d2), is(0)); assertThat(zero.compareTo(d1), is(-1)); assertThat(zero.compareTo(d2), is(-1)); assertThat(d1.compareTo(zero), is(1)); assertThat(d2.compareTo(zero), is(1)); assertThat(d1.compareTo(d2), is(1)); assertThat(d2.compareTo(d1), is(-1)); }
### Question: Wallet { public List<byte[]> getAccountAddresses() { List<byte[]> addresses = new ArrayList<>(); Set<RskAddress> keys = new HashSet<>(); synchronized(accessLock) { for (RskAddress addr: this.initialAccounts) { addresses.add(addr.getBytes()); } for (byte[] address: keyDS.keys()) { keys.add(new RskAddress(address)); } keys.addAll(accounts.keySet()); keys.removeAll(this.initialAccounts); for (RskAddress addr: keys) { addresses.add(addr.getBytes()); } } return addresses; } Wallet(KeyValueDataSource keyDS); List<byte[]> getAccountAddresses(); String[] getAccountAddressesAsHex(); RskAddress addAccount(); RskAddress addAccount(String passphrase); RskAddress addAccount(Account account); Account getAccount(RskAddress addr); Account getAccount(RskAddress addr, String passphrase); boolean unlockAccount(RskAddress addr, String passphrase, long duration); boolean unlockAccount(RskAddress addr, String passphrase); boolean lockAccount(RskAddress addr); byte[] addAccountWithSeed(String seed); byte[] addAccountWithPrivateKey(byte[] privateKeyBytes); RskAddress addAccountWithPrivateKey(byte[] privateKeyBytes, String passphrase); }### Answer: @Test public void getEmptyAccountList() { Wallet wallet = WalletFactory.createWallet(); List<byte[]> addresses = wallet.getAccountAddresses(); Assert.assertNotNull(addresses); Assert.assertTrue(addresses.isEmpty()); }
### Question: Wallet { public byte[] addAccountWithSeed(String seed) { return addAccountWithPrivateKey(Keccak256Helper.keccak256(seed.getBytes(StandardCharsets.UTF_8))); } Wallet(KeyValueDataSource keyDS); List<byte[]> getAccountAddresses(); String[] getAccountAddressesAsHex(); RskAddress addAccount(); RskAddress addAccount(String passphrase); RskAddress addAccount(Account account); Account getAccount(RskAddress addr); Account getAccount(RskAddress addr, String passphrase); boolean unlockAccount(RskAddress addr, String passphrase, long duration); boolean unlockAccount(RskAddress addr, String passphrase); boolean lockAccount(RskAddress addr); byte[] addAccountWithSeed(String seed); byte[] addAccountWithPrivateKey(byte[] privateKeyBytes); RskAddress addAccountWithPrivateKey(byte[] privateKeyBytes, String passphrase); }### Answer: @Test public void addAccountWithSeed() { Wallet wallet = WalletFactory.createWallet(); byte[] address = wallet.addAccountWithSeed("seed"); Assert.assertNotNull(address); byte[] calculatedAddress = ECKey.fromPrivate(Keccak256Helper.keccak256("seed".getBytes())).getAddress(); Assert.assertArrayEquals(calculatedAddress, address); List<byte[]> addresses = wallet.getAccountAddresses(); Assert.assertNotNull(addresses); Assert.assertFalse(addresses.isEmpty()); Assert.assertEquals(1, addresses.size()); byte[] addr = addresses.get(0); Assert.assertNotNull(addr); Assert.assertArrayEquals(address, addr); }
### Question: Wallet { public boolean unlockAccount(RskAddress addr, String passphrase, long duration) { long ending = System.currentTimeMillis() + duration; boolean unlocked = unlockAccount(addr, passphrase); if (unlocked) { synchronized (accessLock) { unlocksTimeouts.put(addr, ending); } } return unlocked; } Wallet(KeyValueDataSource keyDS); List<byte[]> getAccountAddresses(); String[] getAccountAddressesAsHex(); RskAddress addAccount(); RskAddress addAccount(String passphrase); RskAddress addAccount(Account account); Account getAccount(RskAddress addr); Account getAccount(RskAddress addr, String passphrase); boolean unlockAccount(RskAddress addr, String passphrase, long duration); boolean unlockAccount(RskAddress addr, String passphrase); boolean lockAccount(RskAddress addr); byte[] addAccountWithSeed(String seed); byte[] addAccountWithPrivateKey(byte[] privateKeyBytes); RskAddress addAccountWithPrivateKey(byte[] privateKeyBytes, String passphrase); }### Answer: @Test public void unlockNonexistentAccount() { Wallet wallet = WalletFactory.createWallet(); RskAddress addr = new RskAddress("0x0000000000000000000000000000000000000023"); Assert.assertFalse(wallet.unlockAccount(addr, "passphrase")); }
### Question: Wallet { public boolean lockAccount(RskAddress addr) { synchronized (accessLock) { if (!accounts.containsKey(addr)) { return false; } accounts.remove(addr); return true; } } Wallet(KeyValueDataSource keyDS); List<byte[]> getAccountAddresses(); String[] getAccountAddressesAsHex(); RskAddress addAccount(); RskAddress addAccount(String passphrase); RskAddress addAccount(Account account); Account getAccount(RskAddress addr); Account getAccount(RskAddress addr, String passphrase); boolean unlockAccount(RskAddress addr, String passphrase, long duration); boolean unlockAccount(RskAddress addr, String passphrase); boolean lockAccount(RskAddress addr); byte[] addAccountWithSeed(String seed); byte[] addAccountWithPrivateKey(byte[] privateKeyBytes); RskAddress addAccountWithPrivateKey(byte[] privateKeyBytes, String passphrase); }### Answer: @Test public void lockAccount() { Wallet wallet = WalletFactory.createWallet(); byte[] address = wallet.addAccount("passphrase").getBytes(); Assert.assertNotNull(address); Assert.assertTrue(wallet.unlockAccount(new RskAddress(address), "passphrase")); Account account = wallet.getAccount(new RskAddress(address)); Assert.assertNotNull(account); Assert.assertArrayEquals(address, account.getAddress().getBytes()); Assert.assertTrue(wallet.lockAccount(new RskAddress(address))); Account account2 = wallet.getAccount(new RskAddress(address)); Assert.assertNull(account2); } @Test public void lockNonexistentAccount() { Wallet wallet = WalletFactory.createWallet(); RskAddress addr = new RskAddress("0x0000000000000000000000000000000000000023"); Assert.assertFalse(wallet.lockAccount(addr)); }
### Question: Wallet { public Account getAccount(RskAddress addr) { synchronized (accessLock) { if (!accounts.containsKey(addr)) { return null; } if (unlocksTimeouts.containsKey(addr)) { long ending = unlocksTimeouts.get(addr); long time = System.currentTimeMillis(); if (ending < time) { unlocksTimeouts.remove(addr); accounts.remove(addr); return null; } } return new Account(ECKey.fromPrivate(accounts.get(addr))); } } Wallet(KeyValueDataSource keyDS); List<byte[]> getAccountAddresses(); String[] getAccountAddressesAsHex(); RskAddress addAccount(); RskAddress addAccount(String passphrase); RskAddress addAccount(Account account); Account getAccount(RskAddress addr); Account getAccount(RskAddress addr, String passphrase); boolean unlockAccount(RskAddress addr, String passphrase, long duration); boolean unlockAccount(RskAddress addr, String passphrase); boolean lockAccount(RskAddress addr); byte[] addAccountWithSeed(String seed); byte[] addAccountWithPrivateKey(byte[] privateKeyBytes); RskAddress addAccountWithPrivateKey(byte[] privateKeyBytes, String passphrase); }### Answer: @Test public void getUnknownAccount() { Wallet wallet = WalletFactory.createWallet(); RskAddress addr = new RskAddress("0x0000000000000000000000000000000000000023"); Account account = wallet.getAccount(addr); Assert.assertNull(account); }
### Question: Wallet { public byte[] addAccountWithPrivateKey(byte[] privateKeyBytes) { Account account = new Account(ECKey.fromPrivate(privateKeyBytes)); synchronized (accessLock) { RskAddress addr = addAccount(account); if (!this.initialAccounts.contains(addr)) { this.initialAccounts.add(addr); } return addr.getBytes(); } } Wallet(KeyValueDataSource keyDS); List<byte[]> getAccountAddresses(); String[] getAccountAddressesAsHex(); RskAddress addAccount(); RskAddress addAccount(String passphrase); RskAddress addAccount(Account account); Account getAccount(RskAddress addr); Account getAccount(RskAddress addr, String passphrase); boolean unlockAccount(RskAddress addr, String passphrase, long duration); boolean unlockAccount(RskAddress addr, String passphrase); boolean lockAccount(RskAddress addr); byte[] addAccountWithSeed(String seed); byte[] addAccountWithPrivateKey(byte[] privateKeyBytes); RskAddress addAccountWithPrivateKey(byte[] privateKeyBytes, String passphrase); }### Answer: @Test public void addAccountWithPrivateKey() { Wallet wallet = WalletFactory.createWallet(); byte[] privateKeyBytes = Keccak256Helper.keccak256("seed".getBytes()); byte[] address = wallet.addAccountWithPrivateKey(privateKeyBytes); Assert.assertNotNull(address); byte[] calculatedAddress = ECKey.fromPrivate(Keccak256Helper.keccak256("seed".getBytes())).getAddress(); Assert.assertArrayEquals(calculatedAddress, address); List<byte[]> addresses = wallet.getAccountAddresses(); Assert.assertNotNull(addresses); Assert.assertFalse(addresses.isEmpty()); Assert.assertEquals(1, addresses.size()); byte[] addr = addresses.get(0); Assert.assertNotNull(addr); Assert.assertArrayEquals(address, addr); }
### Question: SnapshotManager { @VisibleForTesting public List<Long> getSnapshots() { return this.snapshots; } SnapshotManager( Blockchain blockchain, BlockStore blockStore, TransactionPool transactionPool, MinerServer minerServer); int takeSnapshot(); boolean resetSnapshots(); boolean revertToSnapshot(int snapshotId); @VisibleForTesting List<Long> getSnapshots(); }### Answer: @Test public void createWithNoSnapshot() { Assert.assertNotNull(manager.getSnapshots()); Assert.assertTrue(manager.getSnapshots().isEmpty()); }
### Question: SnapshotManager { public boolean revertToSnapshot(int snapshotId) { if (snapshotId <= 0 || snapshotId > this.snapshots.size()) { return false; } long newBestBlockNumber = this.snapshots.get(snapshotId - 1); this.snapshots = this.snapshots.stream().limit(snapshotId).collect(Collectors.toList()); long currentBestBlockNumber = blockchain.getBestBlock().getNumber(); if (newBestBlockNumber >= currentBestBlockNumber) { return true; } Block block = blockStore.getChainBlockByNumber(newBestBlockNumber); BlockDifficulty difficulty = blockStore.getTotalDifficultyForHash(block.getHash().getBytes()); blockchain.setStatus(block, difficulty); transactionPool.processBest(block); transactionPool.removeTransactions(transactionPool.getPendingTransactions()); transactionPool.removeTransactions(transactionPool.getQueuedTransactions()); for (long nb = blockchain.getBestBlock().getNumber() + 1; nb <= currentBestBlockNumber; nb++) { blockchain.removeBlocksByNumber(nb); } minerServer.buildBlockToMine(block, false); return true; } SnapshotManager( Blockchain blockchain, BlockStore blockStore, TransactionPool transactionPool, MinerServer minerServer); int takeSnapshot(); boolean resetSnapshots(); boolean revertToSnapshot(int snapshotId); @VisibleForTesting List<Long> getSnapshots(); }### Answer: @Test public void revertToNegativeSnapshot() { Assert.assertFalse(manager.revertToSnapshot(-1)); } @Test public void revertToNonExistentSnapshot() { Assert.assertFalse(manager.revertToSnapshot(0)); Assert.assertFalse(manager.revertToSnapshot(1)); Assert.assertFalse(manager.revertToSnapshot(10)); } @Test public void revertToSnapshot() { addBlocks(10); BlockChainStatus status = blockchain.getStatus(); int snapshotId = manager.takeSnapshot(); addBlocks(20); Assert.assertEquals(30, blockchain.getStatus().getBestBlockNumber()); Assert.assertTrue(manager.revertToSnapshot(snapshotId)); BlockChainStatus newStatus = blockchain.getStatus(); Assert.assertEquals(status.getBestBlockNumber(), newStatus.getBestBlockNumber()); Assert.assertEquals(status.getTotalDifficulty(), newStatus.getTotalDifficulty()); Assert.assertEquals(status.getBestBlock().getHash(), newStatus.getBestBlock().getHash()); for (int k = 11; k <= 30; k++) Assert.assertTrue(blockchain.getBlocksByNumber(k).isEmpty()); }
### Question: ReversibleTransactionExecutor { public ProgramResult executeTransaction( Block executionBlock, RskAddress coinbase, byte[] gasPrice, byte[] gasLimit, byte[] toAddress, byte[] value, byte[] data, RskAddress fromAddress) { return executeTransaction_workaround( repositoryLocator.snapshotAt(executionBlock.getHeader()), executionBlock, coinbase, gasPrice, gasLimit, toAddress, value, data, fromAddress ); } ReversibleTransactionExecutor( RepositoryLocator repositoryLocator, TransactionExecutorFactory transactionExecutorFactory); ProgramResult executeTransaction( Block executionBlock, RskAddress coinbase, byte[] gasPrice, byte[] gasLimit, byte[] toAddress, byte[] value, byte[] data, RskAddress fromAddress); @Deprecated ProgramResult executeTransaction_workaround( RepositorySnapshot snapshot, Block executionBlock, RskAddress coinbase, byte[] gasPrice, byte[] gasLimit, byte[] toAddress, byte[] value, byte[] data, RskAddress fromAddress); }### Answer: @Test public void executeTransactionHello() { TestContract hello = TestContract.hello(); CallTransaction.Function helloFn = hello.functions.get("hello"); RskAddress contractAddress = contractRunner.addContract(hello.runtimeBytecode); RskAddress from = TestUtils.randomAddress(); byte[] gasPrice = Hex.decode("00"); byte[] value = Hex.decode("00"); byte[] gasLimit = Hex.decode("f424"); Block bestBlock = factory.getBlockchain().getBestBlock(); ProgramResult result = reversibleTransactionExecutor.executeTransaction( bestBlock, bestBlock.getCoinbase(), gasPrice, gasLimit, contractAddress.getBytes(), value, helloFn.encode(), from ); Assert.assertNull(result.getException()); Assert.assertArrayEquals( new String[]{"chinchilla"}, helloFn.decodeResult(result.getHReturn())); } @Test public void executeTransactionGreeterOtherSender() { TestContract greeter = TestContract.greeter(); CallTransaction.Function greeterFn = greeter.functions.get("greet"); RskAddress contractAddress = contractRunner.addContract(greeter.runtimeBytecode); RskAddress from = new RskAddress("0000000000000000000000000000000000000023"); byte[] gasPrice = Hex.decode("00"); byte[] value = Hex.decode("00"); byte[] gasLimit = Hex.decode("f424"); Block bestBlock = factory.getBlockchain().getBestBlock(); ProgramResult result = reversibleTransactionExecutor.executeTransaction( bestBlock, bestBlock.getCoinbase(), gasPrice, gasLimit, contractAddress.getBytes(), value, greeterFn.encode("greet me"), from ); Assert.assertTrue(result.isRevert()); } @Test public void executeTransactionCountCallsMultipleTimes() { TestContract countcalls = TestContract.countcalls(); CallTransaction.Function callsFn = countcalls.functions.get("calls"); RskAddress contractAddress = contractRunner.addContract(countcalls.runtimeBytecode); RskAddress from = new RskAddress("0000000000000000000000000000000000000023"); byte[] gasPrice = Hex.decode("00"); byte[] value = Hex.decode("00"); byte[] gasLimit = Hex.decode("f424"); Block bestBlock = factory.getBlockchain().getBestBlock(); ProgramResult result = reversibleTransactionExecutor.executeTransaction( bestBlock, bestBlock.getCoinbase(), gasPrice, gasLimit, contractAddress.getBytes(), value, callsFn.encodeSignature(), from ); Assert.assertNull(result.getException()); Assert.assertArrayEquals( new String[]{"calls: 1"}, callsFn.decodeResult(result.getHReturn())); ProgramResult result2 = reversibleTransactionExecutor.executeTransaction( bestBlock, bestBlock.getCoinbase(), gasPrice, gasLimit, contractAddress.getBytes(), value, callsFn.encodeSignature(), from ); Assert.assertNull(result2.getException()); Assert.assertArrayEquals( new String[]{"calls: 1"}, callsFn.decodeResult(result2.getHReturn())); }
### Question: ConsensusValidationMainchainViewImpl implements ConsensusValidationMainchainView { @Override public synchronized List<BlockHeader> get(Keccak256 startingHashToGetMainchainFrom, int height) { List<BlockHeader> headers = new ArrayList<>(); Keccak256 currentHash = startingHashToGetMainchainFrom; for(int i = 0; i < height; i++) { Block block = blockStore.getBlockByHash(currentHash.getBytes()); BlockHeader header; if (block != null) { header = block.getHeader(); } else { if(pendingHeadersByHash == null) { logger.error("Pending headers by hash has not been set."); return new ArrayList<>(); } header = pendingHeadersByHash.get(currentHash); } if(header == null) { return new ArrayList<>(); } headers.add(header); currentHash = header.getParentHash(); } return headers; } ConsensusValidationMainchainViewImpl(BlockStore blockStore); void setPendingHeaders(Map<Keccak256, BlockHeader> pendingHeadersByHash); @Override synchronized List<BlockHeader> get(Keccak256 startingHashToGetMainchainFrom, int height); }### Answer: @Test public void getWithHeightZeroReturnsEmpty() { BlockStore blockStore = mock(BlockStore.class); ConsensusValidationMainchainView view = new ConsensusValidationMainchainViewImpl(blockStore); List<BlockHeader> result = view.get(new Keccak256(getRandomHash()), 0); assertNotNull(result); assertThat(result.size(), is(0)); } @Test public void getThatFindsAllBlocksOnBlockStore() { BlockStore blockStore = createBlockStore(10); ConsensusValidationMainchainView view = new ConsensusValidationMainchainViewImpl(blockStore); Block bestBlock = blockStore.getBestBlock(); List<BlockHeader> result = view.get(bestBlock.getHash(), 5); assertNotNull(result); assertThat(result.size(), is(5)); assertThat(result.get(0).getHash(), is(bestBlock.getHash())); byte[] bestBlockParentHash = bestBlock.getParentHash().getBytes(); assertThat(result.get(1).getHash(), is(blockStore.getBlockByHash(bestBlockParentHash).getHash())); byte[] blockOneParentHash = result.get(1).getParentHash().getBytes(); assertThat(result.get(2).getHash(), is(blockStore.getBlockByHash(blockOneParentHash).getHash())); byte[] blockTwoParentHash = result.get(2).getParentHash().getBytes(); assertThat(result.get(3).getHash(), is(blockStore.getBlockByHash(blockTwoParentHash).getHash())); byte[] blockThreeParentHash = result.get(3).getParentHash().getBytes(); assertThat(result.get(4).getHash(), is(blockStore.getBlockByHash(blockThreeParentHash).getHash())); } @Test public void getAllBlocksOnBlockStoreAreAllRequestedBlocks() { BlockStore blockStore = createBlockStore(5); ConsensusValidationMainchainView view = new ConsensusValidationMainchainViewImpl(blockStore); Block bestBlock = blockStore.getBestBlock(); List<BlockHeader> result = view.get(bestBlock.getHash(), 5); assertNotNull(result); assertThat(result.size(), is(5)); assertThat(result.get(0).getHash(), is(bestBlock.getHash())); byte[] bestBlockParentHash = bestBlock.getParentHash().getBytes(); assertThat(result.get(1).getHash(), is(blockStore.getBlockByHash(bestBlockParentHash).getHash())); byte[] blockOneParentHash = result.get(1).getParentHash().getBytes(); assertThat(result.get(2).getHash(), is(blockStore.getBlockByHash(blockOneParentHash).getHash())); byte[] blockTwoParentHash = result.get(2).getParentHash().getBytes(); assertThat(result.get(3).getHash(), is(blockStore.getBlockByHash(blockTwoParentHash).getHash())); byte[] blockThreeParentHash = result.get(3).getParentHash().getBytes(); assertThat(result.get(4).getHash(), is(blockStore.getBlockByHash(blockThreeParentHash).getHash())); }