Datasets:
Minata
/
512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files
xet
Community
method2testcases
stringlengths
118
3.08k
### Question: DomainUtils { public static DomainTypeResolver devToolsProtocolResolver(DevToolsProtocol protocol) { return ((domain, object) -> { for (Domain protocolDomain : protocol.getDomains()) { if (protocolDomain.getDomain().equals(domain)) { for (Type type : protocolDomain.getTypes()) { if (type.getId().equals(object)) { return type; } } throw new RuntimeException("Type " + object + " on domain " + domain + " not found!"); } } throw new RuntimeException("Type " + object + " on domain " + domain + " not found!"); }); } static DomainTypeResolver devToolsProtocolResolver(DevToolsProtocol protocol); }### Answer: @Test(expected = RuntimeException.class) public void testDevToolsProtocolResolverOnNonExistingDomain() { DevToolsProtocol devToolsProtocol = new DevToolsProtocol(); devToolsProtocol.setDomains(Collections.emptyList()); DomainUtils.devToolsProtocolResolver(devToolsProtocol).resolve("domain", "test"); } @Test(expected = RuntimeException.class) public void testDevToolsProtocolResolverOnNonExistingType() { Type type1 = new StringType(); type1.setId("test-type"); Type type2 = new StringType(); type2.setId("test-type"); Domain domain = new Domain(); domain.setDomain("domain"); domain.setTypes(Arrays.asList(type1, type2)); DevToolsProtocol devToolsProtocol = new DevToolsProtocol(); devToolsProtocol.setDomains(Collections.singletonList(domain)); DomainUtils.devToolsProtocolResolver(devToolsProtocol).resolve("domain", "test"); } @Test public void testDevToolsProtocolResolver() { Type type = new StringType(); type.setId("test"); Domain domain = new Domain(); domain.setDomain("domain"); domain.setTypes(Collections.singletonList(type)); DevToolsProtocol devToolsProtocol = new DevToolsProtocol(); devToolsProtocol.setDomains(Collections.singletonList(domain)); Type resolvedType = DomainUtils.devToolsProtocolResolver(devToolsProtocol).resolve("domain", "test"); assertEquals(type, resolvedType); }
### Question: JavaInterfaceBuilderImpl extends BaseBuilder implements JavaInterfaceBuilder { static boolean isClassList(String value) { if (SINGLE_CLASS.matcher(value).matches()) { return true; } return CLASS_LIST.matcher(value).matches(); } JavaInterfaceBuilderImpl(String packageName, String name, String annotationsPackage); static void main(String[] args); @Override void setJavaDoc(String comment); @Override void addAnnotation(String annotationName); @Override void addMethodAnnotation(String methodName, String annotationName); @Override void addParametrizedMethodAnnotation( String methodName, String annotationName, String parameter); @Override String getName(); @Override void addImport(String packageName, String object); @Override void addMethod( String name, String description, List<MethodParam> methodParams, String returnType); }### Answer: @Test public void testIsClassList() { assertFalse(isClassList("")); assertFalse(isClassList("test")); assertTrue(isClassList("test.class")); assertTrue(isClassList("{test.class}")); assertTrue(isClassList("{test.class,test2.class}")); assertTrue(isClassList("{ test.class , test2.class }")); assertFalse(isClassList("{ test.class . test2.class }")); assertTrue(isClassList("{test.class,test2.class}")); assertTrue(isClassList("{test.class,test2.class,test3.class}")); }
### Question: CommandInvocationHandler implements InvocationHandler { public static boolean isEventSubscription(Method method) { String name = method.getName(); Parameter[] parameters = method.getParameters(); return name.startsWith(EVENT_LISTENER_PREFIX) && EventListener.class.equals(method.getReturnType()) && (parameters != null && parameters.length == 1 && EventHandler.class.isAssignableFrom(parameters[0].getType())); } void setChromeDevToolsService(ChromeDevToolsService chromeDevToolsService); @Override Object invoke(Object unused, Method method, Object[] args); static boolean isEventSubscription(Method method); }### Answer: @Test public void testIsEventSubscription() { assertFalse(CommandInvocationHandler.isEventSubscription(getMethodByName("voidMethod"))); assertFalse( CommandInvocationHandler.isEventSubscription(getMethodByName("stringMethodWithParams"))); assertFalse( CommandInvocationHandler.isEventSubscription(getMethodByName("onEventListenerTestMethod"))); assertFalse( CommandInvocationHandler.isEventSubscription( getMethodByName("onEventListenerTestMethod1"))); assertFalse( CommandInvocationHandler.isEventSubscription( getMethodByName("onEventListenerTestMethod2"))); assertFalse( CommandInvocationHandler.isEventSubscription( getMethodByName("onEventListenerTestMethod3"))); assertTrue( CommandInvocationHandler.isEventSubscription( getMethodByName("onEventListenerTestMethod4"))); }
### Question: ConfigurationUtils { public static long systemProperty(String name, long defaultValue) { String propertyValue = System.getProperty(name); if (propertyValue != null) { try { return Long.parseLong(propertyValue.trim()); } catch (NumberFormatException ex) { LOGGER.error("Failed parsing {} value.", name, ex); } } return defaultValue; } private ConfigurationUtils(); static long systemProperty(String name, long defaultValue); static String systemProperty(String name, String defaultValue); }### Answer: @Test public void testSystemProperty() { final String propertyName = "testSystemProperty"; assertEquals(10, ConfigurationUtils.systemProperty(propertyName, 10)); assertEquals("10", ConfigurationUtils.systemProperty(propertyName, "10")); System.setProperty(propertyName, "invalid-value"); assertEquals(10, ConfigurationUtils.systemProperty(propertyName, 10)); System.setProperty(propertyName, "123"); assertEquals(123, ConfigurationUtils.systemProperty(propertyName, 10)); assertEquals("123", ConfigurationUtils.systemProperty(propertyName, "10")); System.setProperty(propertyName, ""); assertEquals("10", ConfigurationUtils.systemProperty(propertyName, "10")); System.setProperty(propertyName, " "); assertEquals("10", ConfigurationUtils.systemProperty(propertyName, "10")); System.setProperty(propertyName, " 123 "); assertEquals("123", ConfigurationUtils.systemProperty(propertyName, "10")); }
### Question: ProxyUtils { @SuppressWarnings("unchecked") public static <T> T createProxyFromAbstract( Class<T> clazz, Class[] paramTypes, Object[] args, InvocationHandler invocationHandler) { ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.setSuperclass(clazz); proxyFactory.setFilter(method -> Modifier.isAbstract(method.getModifiers())); try { return (T) proxyFactory.create( paramTypes, args, (o, method, method1, objects) -> invocationHandler.invoke(o, method, objects)); } catch (Exception e) { LOGGER.error("Failed creating proxy from abstract class", e); throw new RuntimeException("Failed creating proxy from abstract class", e); } } private ProxyUtils(); @SuppressWarnings("unchecked") static T createProxy(Class<T> clazz, InvocationHandler invocationHandler); @SuppressWarnings("unchecked") static T createProxyFromAbstract( Class<T> clazz, Class[] paramTypes, Object[] args, InvocationHandler invocationHandler); }### Answer: @Test(expected = RuntimeException.class) public void testCreateProxyFromAbstractThrowsException() { createProxyFromAbstract( ChromeDevToolsServiceImpl.class, new Class[] {}, new Object[] {}, (unused, method, args) -> null); }
### Question: JavaInterfaceBuilderImpl extends BaseBuilder implements JavaInterfaceBuilder { static List<String> getClassList(String value) { final List<String> result = new ArrayList<>(); if (isClassList(value)) { if (SINGLE_CLASS.matcher(value).matches()) { result.add(value.trim()); return result; } final Matcher matcher = CLASS_LIST_CONTENT.matcher(value); if (matcher.matches()) { final String content = matcher.group(1); final String[] items = content.trim().split(","); for (int i = 0; i < items.length; i++) { result.add(items[i].trim()); } } } return result; } JavaInterfaceBuilderImpl(String packageName, String name, String annotationsPackage); static void main(String[] args); @Override void setJavaDoc(String comment); @Override void addAnnotation(String annotationName); @Override void addMethodAnnotation(String methodName, String annotationName); @Override void addParametrizedMethodAnnotation( String methodName, String annotationName, String parameter); @Override String getName(); @Override void addImport(String packageName, String object); @Override void addMethod( String name, String description, List<MethodParam> methodParams, String returnType); }### Answer: @Test public void testGetClassList() { assertEquals( list("test.class", "test2.class", "test3.class"), getClassList("{test.class, test2.class , test3.class }")); assertEquals( list("test.class", "test2.class", "test3.class"), getClassList("{test.class,test2.class,test3.class}")); assertEquals(list("test.class"), getClassList("{test.class}")); assertEquals(list(), getClassList("{test.clas}")); assertEquals(list(), getClassList("{}")); assertEquals(list("test.class"), getClassList("test.class")); }
### Question: ChromeDevToolsServiceImpl implements ChromeDevToolsService, Consumer<String>, AutoCloseable { @Override public void close() { if (!isClosed()) { webSocketService.close(); if (chromeService != null) { chromeService.clearChromeDevToolsServiceCache(chromeTab); } eventExecutorService.shutdown(); closeLatch.countDown(); } } ChromeDevToolsServiceImpl( WebSocketService webSocketService, ChromeDevToolsServiceConfiguration configuration); void setChromeService(ChromeServiceImpl chromeService); void setChromeTab(ChromeTab chromeTab); @Override T invoke(String returnProperty, Class<T> clazz, MethodInvocation methodInvocation); @Override T invoke( String returnProperty, Class<T> clazz, Class<?>[] returnTypeClasses, MethodInvocation methodInvocation); @Override void close(); @Override boolean isClosed(); @Override void waitUntilClosed(); @Override EventListener addEventListener( String domainName, String eventName, EventHandler eventHandler, Class<?> eventType); @Override void removeEventListener(EventListener eventListener); @Override void accept(String message); }### Answer: @Test public void testClose() { webSocketService.close(); eventExecutorService.shutdown(); replayAll(); service.close(); verifyAll(); resetAll(); replayAll(); service.close(); verifyAll(); }
### Question: ChromeDevToolsServiceImpl implements ChromeDevToolsService, Consumer<String>, AutoCloseable { @Override public EventListener addEventListener( String domainName, String eventName, EventHandler eventHandler, Class<?> eventType) { String name = domainName + "." + eventName; EventListenerImpl eventListener = new EventListenerImpl(name, eventHandler, eventType, this); eventNameToHandlersMap.computeIfAbsent(name, this::createEventHandlerSet).add(eventListener); return eventListener; } ChromeDevToolsServiceImpl( WebSocketService webSocketService, ChromeDevToolsServiceConfiguration configuration); void setChromeService(ChromeServiceImpl chromeService); void setChromeTab(ChromeTab chromeTab); @Override T invoke(String returnProperty, Class<T> clazz, MethodInvocation methodInvocation); @Override T invoke( String returnProperty, Class<T> clazz, Class<?>[] returnTypeClasses, MethodInvocation methodInvocation); @Override void close(); @Override boolean isClosed(); @Override void waitUntilClosed(); @Override EventListener addEventListener( String domainName, String eventName, EventHandler eventHandler, Class<?> eventType); @Override void removeEventListener(EventListener eventListener); @Override void accept(String message); }### Answer: @Test public void testAddEventListener() { EventHandler<String> eventHandler = event -> {}; EventListener eventListener = service.addEventListener("domain", "event", eventHandler, String.class); assertNotNull(eventListener); assertEquals(eventHandler, ((EventListenerImpl) eventListener).getHandler()); assertEquals("domain.event", ((EventListenerImpl) eventListener).getKey()); assertEquals(String.class, ((EventListenerImpl) eventListener).getParamType()); service.removeEventListener(eventListener); }
### Question: ChromeServiceImpl implements ChromeService { @Override public void activateTab(ChromeTab tab) throws ChromeServiceException { request(Void.class, "http: } ChromeServiceImpl(String host, int port, WebSocketServiceFactory webSocketServiceFactory); ChromeServiceImpl(String host, int port); ChromeServiceImpl(int port); ChromeServiceImpl(int port, WebSocketServiceFactory webSocketServiceFactory); void setWebSocketServiceFactory(WebSocketServiceFactory webSocketServiceFactory); @Override List<ChromeTab> getTabs(); @Override ChromeTab createTab(); @Override ChromeTab createTab(String tab); @Override void activateTab(ChromeTab tab); @Override void closeTab(ChromeTab tab); @Override ChromeVersion getVersion(); @Override synchronized ChromeDevToolsService createDevToolsService(ChromeTab tab); @Override synchronized ChromeDevToolsService createDevToolsService( ChromeTab tab, ChromeDevToolsServiceConfiguration chromeDevToolsServiceConfiguration); int getPort(); String getHost(); void clearChromeDevToolsServiceCache(ChromeTab tab); static String inputStreamToString(InputStream inputStream); static final String ABOUT_BLANK_PAGE; }### Answer: @Test public void testActivateTab() throws IOException, ChromeServiceException, InterruptedException { MockWebServer server = new MockWebServer(); ObjectMapper objectMapper = new ObjectMapper(); ChromeTab tab = objectMapper.readerFor(ChromeTab.class).readValue(getFixture("chrome/tab.json")); server.enqueue(new MockResponse()); server.start(); ChromeServiceImpl service = new ChromeServiceImpl(server.getHostName(), server.getPort()); service.activateTab(tab); RecordedRequest request = server.takeRequest(); assertEquals(1, server.getRequestCount()); assertEquals( "GET /json/activate/(2C5C79DD1137419CC8839D61D91CEB2A) HTTP/1.1", request.getRequestLine()); server.shutdown(); }
### Question: ChromeServiceImpl implements ChromeService { @Override public void closeTab(ChromeTab tab) throws ChromeServiceException { request(Void.class, "http: clearChromeDevToolsServiceCache(tab); } ChromeServiceImpl(String host, int port, WebSocketServiceFactory webSocketServiceFactory); ChromeServiceImpl(String host, int port); ChromeServiceImpl(int port); ChromeServiceImpl(int port, WebSocketServiceFactory webSocketServiceFactory); void setWebSocketServiceFactory(WebSocketServiceFactory webSocketServiceFactory); @Override List<ChromeTab> getTabs(); @Override ChromeTab createTab(); @Override ChromeTab createTab(String tab); @Override void activateTab(ChromeTab tab); @Override void closeTab(ChromeTab tab); @Override ChromeVersion getVersion(); @Override synchronized ChromeDevToolsService createDevToolsService(ChromeTab tab); @Override synchronized ChromeDevToolsService createDevToolsService( ChromeTab tab, ChromeDevToolsServiceConfiguration chromeDevToolsServiceConfiguration); int getPort(); String getHost(); void clearChromeDevToolsServiceCache(ChromeTab tab); static String inputStreamToString(InputStream inputStream); static final String ABOUT_BLANK_PAGE; }### Answer: @Test public void testCloseTab() throws IOException, ChromeServiceException, InterruptedException { MockWebServer server = new MockWebServer(); ObjectMapper objectMapper = new ObjectMapper(); ChromeTab tab = objectMapper.readerFor(ChromeTab.class).readValue(getFixture("chrome/tab.json")); server.enqueue(new MockResponse()); server.start(); ChromeServiceImpl service = new ChromeServiceImpl(server.getHostName(), server.getPort()); service.closeTab(tab); RecordedRequest request = server.takeRequest(); assertEquals(1, server.getRequestCount()); assertEquals( "GET /json/close/(2C5C79DD1137419CC8839D61D91CEB2A) HTTP/1.1", request.getRequestLine()); server.shutdown(); }
### Question: ChromeServiceImpl implements ChromeService { public void clearChromeDevToolsServiceCache(ChromeTab tab) { ChromeDevToolsService chromeDevToolsService = chromeDevToolServiceCache.remove(tab.getId()); if (chromeDevToolsService != null) { chromeDevToolsService.close(); } } ChromeServiceImpl(String host, int port, WebSocketServiceFactory webSocketServiceFactory); ChromeServiceImpl(String host, int port); ChromeServiceImpl(int port); ChromeServiceImpl(int port, WebSocketServiceFactory webSocketServiceFactory); void setWebSocketServiceFactory(WebSocketServiceFactory webSocketServiceFactory); @Override List<ChromeTab> getTabs(); @Override ChromeTab createTab(); @Override ChromeTab createTab(String tab); @Override void activateTab(ChromeTab tab); @Override void closeTab(ChromeTab tab); @Override ChromeVersion getVersion(); @Override synchronized ChromeDevToolsService createDevToolsService(ChromeTab tab); @Override synchronized ChromeDevToolsService createDevToolsService( ChromeTab tab, ChromeDevToolsServiceConfiguration chromeDevToolsServiceConfiguration); int getPort(); String getHost(); void clearChromeDevToolsServiceCache(ChromeTab tab); static String inputStreamToString(InputStream inputStream); static final String ABOUT_BLANK_PAGE; }### Answer: @Test public void testClearChromeDevToolsServiceCache() throws IOException { ChromeServiceImpl service = new ChromeServiceImpl(9222, webSocketServiceFactory); service.clearChromeDevToolsServiceCache(createChromeTab("UNUSED")); }
### Question: WebSocketServiceImpl implements WebSocketService { public static WebSocketService create(URI uri) throws WebSocketServiceException { WebSocketServiceImpl webSocketService = new WebSocketServiceImpl(); webSocketService.connect(uri); return webSocketService; } WebSocketServiceImpl(Session session); private WebSocketServiceImpl(); static WebSocketService create(URI uri); @Override void connect(URI uri); @Override void send(String message); @Override void addMessageHandler(Consumer<String> consumer); @Override void close(); @Override boolean closed(); @SuppressWarnings("unchecked") static WebSocketContainer getWebSocketContainer(); static final String WEB_SOCKET_CONTAINER_FACTORY_PROPERTY; }### Answer: @Test(expected = WebSocketServiceException.class) public void testConnectionOnNonExistentServer() throws WebSocketServiceException, InterruptedException { final int port = randomPort(); WebSocketServiceImpl.create(createURI(port)); }
### Question: WebSocketServiceImpl implements WebSocketService { @Override public void addMessageHandler(Consumer<String> consumer) throws WebSocketServiceException { if (session == null) { throw new WebSocketServiceException( "You first must connect to ws server in order to receive messages."); } if (!session.getMessageHandlers().isEmpty()) { throw new WebSocketServiceException("You are already subscribed to this web socket service."); } session.addMessageHandler( new MessageHandler.Whole<String>() { @Override public void onMessage(String message) { LOGGER.debug("Received message {} on {}", message, session.getRequestURI()); consumer.accept(message); } }); } WebSocketServiceImpl(Session session); private WebSocketServiceImpl(); static WebSocketService create(URI uri); @Override void connect(URI uri); @Override void send(String message); @Override void addMessageHandler(Consumer<String> consumer); @Override void close(); @Override boolean closed(); @SuppressWarnings("unchecked") static WebSocketContainer getWebSocketContainer(); static final String WEB_SOCKET_CONTAINER_FACTORY_PROPERTY; }### Answer: @Test(expected = WebSocketServiceException.class) public void testAddMessageHandlerThrowsExceptionIfNotConnected() throws WebSocketServiceException { WebSocketServiceImpl socketService = new WebSocketServiceImpl(null); socketService.addMessageHandler(message -> {}); } @Test(expected = WebSocketServiceException.class) public void testAddMessageHandlerThrowsExceptionIfHandlerAlreadyAdded() throws WebSocketServiceException { Session session = mock(Session.class); Set<MessageHandler> messageHandlerSet = new HashSet<>(); messageHandlerSet.add(null); expect(session.getMessageHandlers()).andReturn(messageHandlerSet); replay(session); WebSocketServiceImpl socketService = new WebSocketServiceImpl(session); socketService.addMessageHandler(message -> {}); verify(session); }
### Question: ChromeDevToolsUtils { public static void closeQuietly(Closeable closeable) { if (closeable != null) { try { closeable.close(); } catch (IOException e) { } } } static void closeQuietly(Closeable closeable); static void waitForEvent(Function<EventHandler<T>, EventListener> eventConsumer); }### Answer: @Test public void testCloseQuietly() throws IOException { Closeable closeable = mock(Closeable.class); Closeable closeableWithException = mock(Closeable.class); closeable.close(); closeableWithException.close(); expectLastCall().andThrow(new IOException()); replay(closeable, closeableWithException); ChromeDevToolsUtils.closeQuietly(null); ChromeDevToolsUtils.closeQuietly(closeable); ChromeDevToolsUtils.closeQuietly(closeableWithException); verify(closeable, closeableWithException); }
### Question: Utils { public static long calculateNotifTime(Long nowMillis, int hourToNotify) { DateTime now = new DateTime(nowMillis); DateTime timeToNotify = new DateTime(nowMillis); timeToNotify = timeToNotify.withHourOfDay(hourToNotify); if (timeToNotify.isBefore(now)) { timeToNotify = timeToNotify.plusDays(1); } return timeToNotify.getMillis(); } static String getCongrats(Context ctx, Event event); static String getEventLabel(Context ctx, Event event); static String getEventLabel(Context ctx, EditableEvent evt); static void startWidgetUpdateAlarm(Context ctx); static void startNotificationAlarm(Context ctx, long time); static void cancelNotificationAlarm(Context ctx); static long calculateNotifTime(Long nowMillis, int hourToNotify); static void setOrCancelNotificationsAlarm(Context context, SharedPreferences prefs); static final String WIDGET_UPDATE; }### Answer: @Test public void testCalculateNotifTime() { DateTime time = new DateTime(); time = time.withHourOfDay(8); DateTime notifyTime = new DateTime(Utils.calculateNotifTime(time.getMillis(), 7)); assertEquals(1000 * 60 * 60 * 23, notifyTime.getMillis() - time.getMillis()); notifyTime = new DateTime(Utils.calculateNotifTime(time.getMillis(), 9)); assertEquals(1000 * 60 * 60, notifyTime.getMillis() - time.getMillis()); }
### Question: DictionaryProperties { public static DictionaryProperties getInstance() { return instance; } private DictionaryProperties(); static DictionaryProperties getInstance(); String getProperty(String key); }### Answer: @Test public void propertiesLoad() { DictionaryProperties dp = DictionaryProperties.getInstance(); Assert.assertNotNull(dp); }
### Question: TreeMenuUIRender implements TreeRender<TreeNodeGeneric<T>> { public String render(TreeNodeGeneric<T> treeNode) { if (null == treeNode || !treeNode.hasChildrens()) return null; HtmlBuilder html = new HtmlBuilder(); List<TreeNodeGeneric<T>> childrenTreeNodes = treeNode.getChildrens(); for (TreeNodeGeneric<T> curTreeNode : childrenTreeNodes) { render(html, curTreeNode); } return html.toString(); } TreeMenuUIRender(); TreeMenuUIRender(String folderCssClass, String leafCssClass); String render(TreeNodeGeneric<T> treeNode); }### Answer: @Test public void testRender() { int loop = 100000; long oneStartTime = System.currentTimeMillis(); String renderString = ""; for (int i = 0; i < loop; i++) { TreeViewItem viewItem1 = new TreeViewItemDefault(false, false, "aa", "aa", "a1", "", "a11", "asd"); TreeViewItem viewItem2 = new TreeViewItemDefault(false, false, "aa", "aa", "a2", "", "a11", "asd"); TreeViewItem viewItem3 = new TreeViewItemDefault(false, false, "aa", "aa", "a3", "a1", "a11", "asd"); TreeViewItem viewItem4 = new TreeViewItemDefault(false, false, "aa", "aa", "a4", "a1", "a11", "asd"); List<TreeViewItem> list = new ArrayList<TreeViewItem>(); list.add(viewItem1); list.add(viewItem2); list.add(viewItem3); list.add(viewItem4); renderString = TreeMenuRenderUtil.contructTreeMenuUI(list, "folder", "file"); } long oneEndTime = System.currentTimeMillis(); System.out.println(renderString); System.out.println("one elapse:" + (oneEndTime - oneStartTime)); }
### Question: GraphTaskOperations implements TaskOperationsDefinition { @Override public List<String> getOperationsList() { Set<String> operationsList = new HashSet<String>(); for (OperationsDefinition def : this.definition) { if ((def.getTransitions() != null)) { for (DestinationDefinition destination : def.getTransitions()) { operationsList.add(destination.getAction()); } } } return new ArrayList<String>(operationsList); } GraphTaskOperations(InputStream graphConfigurationFile); @Override List<String> getOperationsList(); @Override List<String> getOperations(String state); }### Answer: @Test public void getOperationsList() { List<String> list = operations.getOperationsList(); Assert.assertEquals(7, list.size()); Assert.assertTrue(list.contains("claim")); Assert.assertTrue(list.contains("start")); Assert.assertTrue(list.contains("complete")); Assert.assertTrue(list.contains("fail")); Assert.assertTrue(list.contains("release")); Assert.assertTrue(list.contains("suspend")); Assert.assertTrue(list.contains("stop")); }
### Question: GraphTaskOperations implements TaskOperationsDefinition { @Override public List<String> getOperations(String state) { List<String> operationsList = new ArrayList<String>(); for (OperationsDefinition def : this.definition) { if (state.equals(def.getName())) { if ((def.getTransitions() != null)) { for (DestinationDefinition operations : def .getTransitions()) { operationsList.add(operations.getAction()); } } } } return operationsList; } GraphTaskOperations(InputStream graphConfigurationFile); @Override List<String> getOperationsList(); @Override List<String> getOperations(String state); }### Answer: @Test public void getOperations() { List<String> tasks = operations.getOperations("READY"); Assert.assertEquals(2, tasks.size()); Assert.assertTrue(tasks.contains("claim")); Assert.assertTrue(tasks.contains("suspend")); }
### Question: ClassLevelTimeoutBean { public void timeout(boolean shouldTimeout) { if (shouldTimeout) { try { Thread.sleep(AWAIT); } catch (InterruptedException ex) { } } } void timeout(boolean shouldTimeout); static final long AWAIT; }### Answer: @Test public void timeoutTest() { try { classLevelTimeoutBean.timeout(true); } catch (TimeoutException toe) { return; } Assert.fail(); }
### Question: MethodLevelTimeoutBean { @Timeout(value = 2, unit = ChronoUnit.SECONDS) public void timeout(boolean shouldTimeout) { if (shouldTimeout) { try { Thread.sleep(AWAIT); } catch (InterruptedException ex) { } } } @Timeout(value = 2, unit = ChronoUnit.SECONDS) void timeout(boolean shouldTimeout); static final long AWAIT; }### Answer: @Test public void timeoutTest() { try { methodLevelTimeoutBean.timeout(true); } catch (TimeoutException toe) { return; } Assert.fail(); }
### Question: AsynchronousTimeoutBean { @Asynchronous public Future<Boolean> timeout(boolean shouldTimeout) { Boolean timedOut = false; if (shouldTimeout) { try { Thread.sleep(AWAIT); } catch (InterruptedException ex) { timedOut = true; } } return CompletableFuture.completedFuture(timedOut); } @Asynchronous Future<Boolean> timeout(boolean shouldTimeout); static final long AWAIT; }### Answer: @Test public void timeoutTest() throws InterruptedException, ExecutionException { Future<Boolean> future = asynchronousTimeoutBean.timeout(true); try { future.get(); } catch (TimeoutException toe) { return; } catch (ExecutionException ex) { if (ex.getCause() instanceof TimeoutException) { return; } } Assert.fail(); }
### Question: FallbackBean { @Retry(maxRetries = 1) @Fallback(StringFallbackHandler.class) public String demonstrateFallbackHandler(boolean fallback) { if (fallback) { throw new RuntimeException("I failed somehow! Save me MicroProfile!"); } else { return defaultResponse; } } @Retry(maxRetries = 1) @Fallback(StringFallbackHandler.class) String demonstrateFallbackHandler(boolean fallback); @Retry(maxRetries = 1) @Fallback(fallbackMethod = "fallbackMethodExample") String demonstrateFallbackMethod(boolean fallback); String fallbackMethodExample(boolean fallback); static final String defaultResponse; static final String expectedResponse; }### Answer: @Test public void fallbackHandlerTest() { String result = fallbackBean.demonstrateFallbackHandler(true); Assert.assertTrue("Did not get the expected result", result.equals(FallbackBean.expectedResponse)); }
### Question: FallbackBean { @Retry(maxRetries = 1) @Fallback(fallbackMethod = "fallbackMethodExample") public String demonstrateFallbackMethod(boolean fallback) { if (fallback) { throw new RuntimeException("I failed somehow! Save me MicroProfile!"); } else { return defaultResponse; } } @Retry(maxRetries = 1) @Fallback(StringFallbackHandler.class) String demonstrateFallbackHandler(boolean fallback); @Retry(maxRetries = 1) @Fallback(fallbackMethod = "fallbackMethodExample") String demonstrateFallbackMethod(boolean fallback); String fallbackMethodExample(boolean fallback); static final String defaultResponse; static final String expectedResponse; }### Answer: @Test public void fallbackMethodTest() { String result = fallbackBean.demonstrateFallbackMethod(true); Assert.assertTrue("Did not get the expected result", result.equals(FallbackBean.expectedResponse)); }
### Question: RetryBean { public int demonstrateRetry() { if (method1Counter < expectedAttempts) { method1Counter++; throw new RuntimeException("Oh noes! Some exception! Method Counter is currently: " + method1Counter); } return method1Counter; } int demonstrateRetry(); @Retry(maxRetries = 5, abortOn = InterruptedException.class) int demonstrateAbort(boolean abort); void resetCounters(); static final int expectedAttempts; }### Answer: @Test public void retryTest() { int numberOfAttempts = 0; numberOfAttempts = retryBean.demonstrateRetry(); Assert.assertTrue("Didn't get the expected number of attempts: " + numberOfAttempts, numberOfAttempts == RetryBean.expectedAttempts); }
### Question: MultiplicationOperation implements Operation { @Override public int calculate(int a, int b) { return a * b; } @Override int calculate(int a, int b); @Override String name(); }### Answer: @Test public void testModulus() { Operation op = new MultiplicationOperation(); assertThat(op.calculate(5, 2)).isEqualTo(10); assertThat(op.calculate(10, 5)).isEqualTo(50); assertThat(op.calculate(4, 2)).isEqualTo(8); }
### Question: AdditionOperation implements Operation { @Override public int calculate(int a, int b) { return a + b; } @Override int calculate(int a, int b); @Override String name(); }### Answer: @Test public void testModulus() { Operation op = new AdditionOperation(); assertThat(op.calculate(5, 2)).isEqualTo(7); assertThat(op.calculate(10, 5)).isEqualTo(15); assertThat(op.calculate(4, 2)).isEqualTo(6); }
### Question: SubtractionOperation implements Operation { @Override public int calculate(int a, int b) { return b - a; } @Override int calculate(int a, int b); @Override String name(); }### Answer: @Test public void testSubtraction() { Operation op = new SubtractionOperation(); assertThat(op.calculate(5, 2)).isEqualTo(-3); assertThat(op.calculate(10, 5)).isEqualTo(-5); assertThat(op.calculate(4, 2)).isEqualTo(-2); }
### Question: SubtractionOperation implements Operation { @Override public int calculate(int a, int b) { return a - b; } @Override int calculate(int a, int b); @Override String name(); }### Answer: @Test public void testSubtraction() { Operation op = new SubtractionOperation(); assertThat(op.calculate(5, 2)).isEqualTo(3); assertThat(op.calculate(10, 5)).isEqualTo(5); assertThat(op.calculate(4, 2)).isEqualTo(2); }
### Question: MultiplicationOperation implements Operation { @Override public int calculate(int a, int b) { return a * b - 1; } @Override int calculate(int a, int b); @Override String name(); }### Answer: @Test public void testModulus() { Operation op = new MultiplicationOperation(); assertThat(op.calculate(5, 2)).isEqualTo(9); assertThat(op.calculate(10, 5)).isEqualTo(49); assertThat(op.calculate(4, 2)).isEqualTo(7); }
### Question: ModulusOperation implements Operation { @Override public int calculate(int a, int b) { return a % b; } @Override int calculate(int a, int b); @Override String name(); }### Answer: @Test public void testModulus() { Operation op = new ModulusOperation(); assertThat(op.calculate(5, 2)).isEqualTo(1); assertThat(op.calculate(10, 5)).isEqualTo(0); assertThat(op.calculate(4, 2)).isEqualTo(0); }
### Question: AndroidNfcReader extends AbstractSelectionLocalReader implements NfcAdapter.ReaderCallback { @Override protected void closePhysicalChannel() throws KeypleChannelStateException { try { if (tagProxy != null) { tagProxy.close(); notifyObservers(new ReaderEvent(PLUGIN_NAME, READER_NAME, ReaderEvent.EventType.SE_REMOVAL, null)); LOG.info("Disconnected tag : " + printTagId()); } } catch (IOException e) { LOG.error("Disconnecting error"); throw new KeypleChannelStateException("Error while closing physical channel", e); } tagProxy = null; } AndroidNfcReader(); Map<String, String> getParameters(); @Override void setParameter(String key, String value); @Override TransmissionMode getTransmissionMode(); @Override void onTagDiscovered(Tag tag); String printTagId(); static final String FLAG_READER_SKIP_NDEF_CHECK; static final String FLAG_READER_NO_PLATFORM_SOUNDS; static final String FLAG_READER_PRESENCE_CHECK_DELAY; }### Answer: @Test(expected = KeypleReaderException.class) public void closePhysicalChannelError() throws KeypleBaseException, IOException { insertSe(); when(tagProxy.isConnected()).thenReturn(true); doThrow(new IOException()).when(tagProxy).close(); reader.closePhysicalChannel(); } @Test public void closePhysicalChannelSuccess() throws KeypleReaderException { insertSe(); when(tagProxy.isConnected()).thenReturn(true); reader.closePhysicalChannel(); }
### Question: AndroidNfcReader extends AbstractSelectionLocalReader implements NfcAdapter.ReaderCallback { @Override protected boolean protocolFlagMatches(SeProtocol protocolFlag) { return protocolFlag.equals(Protocol.ANY) || protocolsMap.containsKey(protocolFlag) && protocolsMap.get(protocolFlag).equals(tagProxy.getTech()); } AndroidNfcReader(); Map<String, String> getParameters(); @Override void setParameter(String key, String value); @Override TransmissionMode getTransmissionMode(); @Override void onTagDiscovered(Tag tag); String printTagId(); static final String FLAG_READER_SKIP_NDEF_CHECK; static final String FLAG_READER_NO_PLATFORM_SOUNDS; static final String FLAG_READER_PRESENCE_CHECK_DELAY; }### Answer: @Test public void protocolFlagMatchesTrue() throws KeypleBaseException, IOException { insertSe(); reader.addSeProtocolSetting( new SeProtocolSetting(AndroidNfcProtocolSettings.SETTING_PROTOCOL_ISO14443_4)); when(tagProxy.getTech()) .thenReturn(AndroidNfcProtocolSettings.SETTING_PROTOCOL_ISO14443_4.getValue()); Assert.assertTrue(reader.protocolFlagMatches(ContactlessProtocols.PROTOCOL_ISO14443_4)); }
### Question: AndroidNfcReader extends AbstractSelectionLocalReader implements NfcAdapter.ReaderCallback { void processIntent(Intent intent) { Tag tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG); this.onTagDiscovered(tag); } AndroidNfcReader(); Map<String, String> getParameters(); @Override void setParameter(String key, String value); @Override TransmissionMode getTransmissionMode(); @Override void onTagDiscovered(Tag tag); String printTagId(); static final String FLAG_READER_SKIP_NDEF_CHECK; static final String FLAG_READER_NO_PLATFORM_SOUNDS; static final String FLAG_READER_PRESENCE_CHECK_DELAY; }### Answer: @Test public void processIntent() { reader.processIntent(intent); Assert.assertTrue(true); }
### Question: AndroidNfcReader extends AbstractSelectionLocalReader implements NfcAdapter.ReaderCallback { public String printTagId() { if (tagProxy != null && tagProxy.getTag() != null) { StringBuilder techList = new StringBuilder(); String[] techs = tagProxy.getTag().getTechList(); for (int i = 0; i < techs.length; i++) { techList.append(techs[i].replace("android.nfc.tech.", "")); if (i + 1 < techs.length) techList.append(", "); } StringBuilder tagId = new StringBuilder(); for (byte b : tagProxy.getTag().getId()) { tagId.append(String.format("%02X ", b)); } return tagId + " - " + techList; } else { return "no-tag"; } } AndroidNfcReader(); Map<String, String> getParameters(); @Override void setParameter(String key, String value); @Override TransmissionMode getTransmissionMode(); @Override void onTagDiscovered(Tag tag); String printTagId(); static final String FLAG_READER_SKIP_NDEF_CHECK; static final String FLAG_READER_NO_PLATFORM_SOUNDS; static final String FLAG_READER_PRESENCE_CHECK_DELAY; }### Answer: @Test public void printTagId() { reader.printTagId(); Assert.assertTrue(true); }
### Question: AndroidNfcReader extends AbstractSelectionLocalReader implements NfcAdapter.ReaderCallback { void enableNFCReaderMode(Activity activity) { if (nfcAdapter == null) { nfcAdapter = NfcAdapter.getDefaultAdapter(activity); } int flags = getFlags(); Bundle options = getOptions(); LOG.info("Enabling Read Write Mode with flags : " + flags + " and options : " + options.toString()); nfcAdapter.enableReaderMode(activity, this, flags, options); } AndroidNfcReader(); Map<String, String> getParameters(); @Override void setParameter(String key, String value); @Override TransmissionMode getTransmissionMode(); @Override void onTagDiscovered(Tag tag); String printTagId(); static final String FLAG_READER_SKIP_NDEF_CHECK; static final String FLAG_READER_NO_PLATFORM_SOUNDS; static final String FLAG_READER_PRESENCE_CHECK_DELAY; }### Answer: @Test public void enableReaderMode() { reader.enableNFCReaderMode(activity); Assert.assertTrue(true); }
### Question: AndroidOmapiReader extends AbstractStaticReader { @Override public Map<String, String> getParameters() { Log.w(TAG, "No parameters are supported by AndroidOmapiReader"); return parameters; } protected AndroidOmapiReader(String pluginName, Reader omapiReader, String readerName); @Override Map<String, String> getParameters(); @Override void setParameter(String key, String value); @Override TransmissionMode getTransmissionMode(); @Override boolean isPhysicalChannelOpen(); @Override void openPhysicalChannel(); }### Answer: @Test public void getParameters() throws NoStackTraceThrowable { Assert.assertNotNull(proxyReader.getParameters()); } @Test public void setParameters() throws KeypleBaseException { Map<String, String> parameters = new HashMap<String, String>(); parameters.put("key1", "value1"); proxyReader.setParameters(parameters); Assert.assertTrue(proxyReader.getParameters().size() == 1); Assert.assertTrue(proxyReader.getParameters().get("key1").equals("value1")); }
### Question: AndroidOmapiReader extends AbstractStaticReader { @Override public void setParameter(String key, String value) { Log.w(TAG, "No parameters are supported by AndroidOmapiReader"); parameters.put(key, value); } protected AndroidOmapiReader(String pluginName, Reader omapiReader, String readerName); @Override Map<String, String> getParameters(); @Override void setParameter(String key, String value); @Override TransmissionMode getTransmissionMode(); @Override boolean isPhysicalChannelOpen(); @Override void openPhysicalChannel(); }### Answer: @Test public void setParameter() throws KeypleBaseException { proxyReader.setParameter("key2", "value2"); Assert.assertTrue(proxyReader.getParameters().size() == 1); Assert.assertTrue(proxyReader.getParameters().get("key2").equals("value2")); }
### Question: StubReader extends AbstractThreadedLocalReader { @Override public void setParameter(String name, String value) throws KeypleReaderException { if (name.equals(ALLOWED_PARAMETER_1) || name.equals(ALLOWED_PARAMETER_2)) { parameters.put(name, value); } else if (name.equals(CONTACTS_PARAMETER)) { transmissionMode = TransmissionMode.CONTACTS; } else if (name.equals(CONTACTLESS_PARAMETER)) { transmissionMode = TransmissionMode.CONTACTLESS; } else { throw new KeypleReaderException("parameter name not supported : " + name); } } StubReader(String name); @Override void closePhysicalChannel(); @Override byte[] transmitApdu(byte[] apduIn); @Override void setParameter(String name, String value); @Override Map<String, String> getParameters(); @Override TransmissionMode getTransmissionMode(); void insertSe(StubSecureElement _se); void removeSe(); static final String ALLOWED_PARAMETER_1; static final String ALLOWED_PARAMETER_2; static final String CONTACTLESS_PARAMETER; static final String CONTACTS_PARAMETER; }### Answer: @Test(expected = KeypleReaderException.class) public void testSetWrongParameter() throws Exception { reader.setParameter("WRONG_PARAMETER", "a"); }
### Question: StubReader extends AbstractThreadedLocalReader { @Override public Map<String, String> getParameters() { return parameters; } StubReader(String name); @Override void closePhysicalChannel(); @Override byte[] transmitApdu(byte[] apduIn); @Override void setParameter(String name, String value); @Override Map<String, String> getParameters(); @Override TransmissionMode getTransmissionMode(); void insertSe(StubSecureElement _se); void removeSe(); static final String ALLOWED_PARAMETER_1; static final String ALLOWED_PARAMETER_2; static final String CONTACTLESS_PARAMETER; static final String CONTACTS_PARAMETER; }### Answer: @Test public void testSetParameters() throws Exception { Map<String, String> p1 = new HashMap<String, String>(); p1.put(StubReader.ALLOWED_PARAMETER_1, "a"); p1.put(StubReader.ALLOWED_PARAMETER_2, "a"); reader.setParameters(p1); Map<String, String> p2 = reader.getParameters(); assert (p1.equals(p2)); }
### Question: ByteArrayUtils { public static byte[] fromHex(String hex) { hex = HEX_IGNORED_CHARS.matcher(hex).replaceAll("").toUpperCase(); if (hex.length() % 2 != 0) { throw new IllegalArgumentException("Odd numbered hex array"); } byte[] byteArray = new byte[hex.length() / 2]; for (int i = 0; i < hex.length(); i += 2) { byteArray[i / 2] = (byte) ((Character.digit(hex.charAt(i), 16) << 4) + Character.digit(hex.charAt(i + 1), 16)); } return byteArray; } static byte[] fromHex(String hex); static String toHex(byte[] byteArray); static int threeBytesToInt(byte[] bytes, int offset); }### Answer: @Test(expected = NullPointerException.class) public void fromHex_null() { byte[] bytes = ByteArrayUtils.fromHex(null); } @Test public void fromHex_empty() { byte[] bytes = ByteArrayUtils.fromHex(""); assertEquals(bytes.length, 0); } @Test(expected = IllegalArgumentException.class) public void fromHex_odd_length() { byte[] bytes = ByteArrayUtils.fromHex(HEXSTRING_ODD); } @Test public void fromHex_bad_hex() { byte[] bytes = ByteArrayUtils.fromHex(HEXSTRING_BAD); } @Test public void fromHex_good_hex() { byte[] bytes = ByteArrayUtils.fromHex(HEXSTRING_GOOD); assertArrayEquals(bytes, BYTEARRAY_GOOD); }
### Question: ByteArrayUtils { public static String toHex(byte[] byteArray) { if (byteArray == null) { return ""; } StringBuilder hexStringBuilder = new StringBuilder(); for (int i = 0; i < byteArray.length; i++) { hexStringBuilder.append(byteToHex[byteArray[i] & 0xFF]); } return hexStringBuilder.toString(); } static byte[] fromHex(String hex); static String toHex(byte[] byteArray); static int threeBytesToInt(byte[] bytes, int offset); }### Answer: @Test public void toHex_null() { String hex = ByteArrayUtils.toHex(null); assertEquals(hex.length(), 0); } @Test public void toHex_empty() { byte[] bytes = new byte[0]; String hex = ByteArrayUtils.toHex(bytes); assertEquals(hex.length(), 0); } @Test public void toHex_bytearray_good() { String hex = ByteArrayUtils.toHex(BYTEARRAY_GOOD); assertEquals(hex, HEXSTRING_GOOD); }
### Question: AbstractObservableReader extends AbstractLoggedObservable<ReaderEvent> implements ObservableReader, ProxyReader { public final void addObserver(ReaderObserver observer) { if (super.countObservers() == 0) { logger.debug("Start the reader monitoring."); startObservation(); } super.addObserver(observer); } protected AbstractObservableReader(String pluginName, String readerName); final int compareTo(SeReader seReader); final SeResponseSet transmitSet(SeRequestSet requestSet); final SeResponse transmit(SeRequest seRequest); final void addObserver(ReaderObserver observer); final void removeObserver(ReaderObserver observer); }### Answer: @Test public void testAddObserver() { startObservationCall = new CountDownLatch(5); stopObservationCall = new CountDownLatch(5); spyReader.addObserver(obs1); Assert.assertEquals(1, spyReader.countObservers()); Assert.assertEquals(4, startObservationCall.getCount()); Assert.assertEquals(5, stopObservationCall.getCount()); }
### Question: AbstractObservableReader extends AbstractLoggedObservable<ReaderEvent> implements ObservableReader, ProxyReader { public final void removeObserver(ReaderObserver observer) { super.removeObserver(observer); if (super.countObservers() == 0) { logger.debug("Stop the reader monitoring."); stopObservation(); } } protected AbstractObservableReader(String pluginName, String readerName); final int compareTo(SeReader seReader); final SeResponseSet transmitSet(SeRequestSet requestSet); final SeResponse transmit(SeRequest seRequest); final void addObserver(ReaderObserver observer); final void removeObserver(ReaderObserver observer); }### Answer: @Test public void testRemoveObserver() { startObservationCall = new CountDownLatch(5); stopObservationCall = new CountDownLatch(5); spyReader.addObserver(obs1); spyReader.removeObserver(obs1); Assert.assertEquals(0, spyReader.countObservers()); Assert.assertEquals(4, startObservationCall.getCount()); Assert.assertEquals(4, stopObservationCall.getCount()); }
### Question: ApduRequest implements Serializable { public ApduRequest(byte[] buffer, boolean case4, Set<Integer> successfulStatusCodes) { this.bytes = buffer; this.case4 = case4; this.successfulStatusCodes = successfulStatusCodes; } ApduRequest(byte[] buffer, boolean case4, Set<Integer> successfulStatusCodes); ApduRequest(String name, byte[] buffer, boolean case4, Set<Integer> successfulStatusCodes); ApduRequest(byte[] buffer, boolean case4); ApduRequest(String name, byte[] buffer, boolean case4); boolean isCase4(); void setName(final String name); Set<Integer> getSuccessfulStatusCodes(); String getName(); byte[] getBytes(); @Override String toString(); }### Answer: @Test public void testAPDURequest() { ApduRequest request = getApduSample(); assertNotNull(request); assertTrue(request.isCase4()); assertArrayEquals(getACommand(), request.getBytes()); assertEquals(getAName(), request.getName()); assertEquals(getASuccessFulStatusCode(), request.getSuccessfulStatusCodes()); assertEquals("ApduRequest: NAME = \"" + getAName() + "\", RAWDATA = FEDCBA989005, case4, additional successful status codes = 2328", request.toString()); }
### Question: SeRequestSet implements Serializable { public Set<SeRequest> getRequests() { return sortedRequests; } SeRequestSet(Set<SeRequest> seRequests); SeRequestSet(SeRequest seRequest); void add(SeRequest seRequest); Set<SeRequest> getRequests(); SeRequest getSingleRequest(); @Override String toString(); }### Answer: @Test public void getRequests() { assertArrayEquals(sortedRequests.toArray(), seRequestSet.getRequests().toArray()); }
### Question: SeRequestSet implements Serializable { public SeRequest getSingleRequest() { if (sortedRequests.size() != 1) { throw new IllegalStateException("This method only support ONE element"); } return sortedRequests.iterator().next(); } SeRequestSet(Set<SeRequest> seRequests); SeRequestSet(SeRequest seRequest); void add(SeRequest seRequest); Set<SeRequest> getRequests(); SeRequest getSingleRequest(); @Override String toString(); }### Answer: @Test public void getSingleRequest() { seRequestSet = new SeRequestSet(firstRequest); assertEquals(firstRequest, seRequestSet.getSingleRequest()); }
### Question: SeRequestSet implements Serializable { @Override public String toString() { return sortedRequests.size() + " SeRequest(s)"; } SeRequestSet(Set<SeRequest> seRequests); SeRequestSet(SeRequest seRequest); void add(SeRequest seRequest); Set<SeRequest> getRequests(); SeRequest getSingleRequest(); @Override String toString(); }### Answer: @Test public void toStringNull() { seRequestSet = new SeRequestSet(new HashSet<SeRequest>()); assertNotNull(seRequestSet.toString()); }
### Question: SeRequest implements Serializable { public SeRequest(SeSelector seSelector, List<ApduRequest> apduRequests, ChannelState channelState, SeProtocol protocolFlag) { this.seSelector = seSelector; this.apduRequests = apduRequests; this.channelState = channelState; this.protocolFlag = protocolFlag; } SeRequest(SeSelector seSelector, List<ApduRequest> apduRequests, ChannelState channelState, SeProtocol protocolFlag); SeRequest(List<ApduRequest> apduRequests, ChannelState channelState); SeSelector getSeSelector(); List<ApduRequest> getApduRequests(); boolean isKeepChannelOpen(); SeProtocol getProtocolFlag(); @Override String toString(); }### Answer: @Test public void testSERequest() { assertNotNull(seRequest); }
### Question: SeRequest implements Serializable { public List<ApduRequest> getApduRequests() { return apduRequests; } SeRequest(SeSelector seSelector, List<ApduRequest> apduRequests, ChannelState channelState, SeProtocol protocolFlag); SeRequest(List<ApduRequest> apduRequests, ChannelState channelState); SeSelector getSeSelector(); List<ApduRequest> getApduRequests(); boolean isKeepChannelOpen(); SeProtocol getProtocolFlag(); @Override String toString(); }### Answer: @Test public void getApduRequests() { seRequest = new SeRequest(getSelector(null), apdus, ChannelState.CLOSE_AFTER, Protocol.ANY); assertArrayEquals(apdus.toArray(), seRequest.getApduRequests().toArray()); }
### Question: SeRequest implements Serializable { public boolean isKeepChannelOpen() { return channelState == ChannelState.KEEP_OPEN; } SeRequest(SeSelector seSelector, List<ApduRequest> apduRequests, ChannelState channelState, SeProtocol protocolFlag); SeRequest(List<ApduRequest> apduRequests, ChannelState channelState); SeSelector getSeSelector(); List<ApduRequest> getApduRequests(); boolean isKeepChannelOpen(); SeProtocol getProtocolFlag(); @Override String toString(); }### Answer: @Test public void isKeepChannelOpen() { assertTrue(seRequest.isKeepChannelOpen()); }
### Question: SeRequest implements Serializable { public SeProtocol getProtocolFlag() { return protocolFlag; } SeRequest(SeSelector seSelector, List<ApduRequest> apduRequests, ChannelState channelState, SeProtocol protocolFlag); SeRequest(List<ApduRequest> apduRequests, ChannelState channelState); SeSelector getSeSelector(); List<ApduRequest> getApduRequests(); boolean isKeepChannelOpen(); SeProtocol getProtocolFlag(); @Override String toString(); }### Answer: @Test public void getProtocolFlag() { seRequest = new SeRequest(getSelector(null), new ArrayList<ApduRequest>(), ChannelState.KEEP_OPEN, seProtocol); assertEquals(seProtocol, seRequest.getProtocolFlag()); }
### Question: SeRequest implements Serializable { public SeSelector getSeSelector() { return seSelector; } SeRequest(SeSelector seSelector, List<ApduRequest> apduRequests, ChannelState channelState, SeProtocol protocolFlag); SeRequest(List<ApduRequest> apduRequests, ChannelState channelState); SeSelector getSeSelector(); List<ApduRequest> getApduRequests(); boolean isKeepChannelOpen(); SeProtocol getProtocolFlag(); @Override String toString(); }### Answer: @Test public void getSuccessfulSelectionStatusCodes() { seRequest = new SeRequest(getSelector(selectionStatusCode), new ArrayList<ApduRequest>(), ChannelState.KEEP_OPEN, ContactlessProtocols.PROTOCOL_B_PRIME); assertArrayEquals(selectionStatusCode.toArray(), seRequest.getSeSelector().getAidSelector() .getSuccessfulSelectionStatusCodes().toArray()); }
### Question: SeRequest implements Serializable { @Override public String toString() { return String.format("SeRequest:{REQUESTS = %s, SELECTOR = %s, KEEPCHANNELOPEN = %s}", getApduRequests(), getSeSelector(), channelState); } SeRequest(SeSelector seSelector, List<ApduRequest> apduRequests, ChannelState channelState, SeProtocol protocolFlag); SeRequest(List<ApduRequest> apduRequests, ChannelState channelState); SeSelector getSeSelector(); List<ApduRequest> getApduRequests(); boolean isKeepChannelOpen(); SeProtocol getProtocolFlag(); @Override String toString(); }### Answer: @Test public void toStringNull() { seRequest = new SeRequest(null, null, null, null); assertNotNull(seRequest.toString()); }
### Question: ApduResponse implements Serializable { @Override public boolean equals(Object o) { if (o == this) { return true; } if (!(o instanceof ApduResponse)) { return false; } ApduResponse resp = (ApduResponse) o; return Arrays.equals(resp.getBytes(), this.bytes) && resp.isSuccessful() == this.successful; } ApduResponse(byte[] buffer, Set<Integer> successfulStatusCodes); boolean isSuccessful(); int getStatusCode(); byte[] getBytes(); byte[] getDataOut(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void isEqualsTest() { assertTrue(getAFCI().equals(getAFCI())); } @Test public void isThisEquals() { ApduResponse resp = getAFCI(); assertTrue(resp.equals(resp)); } @Test public void isNotEquals() { ApduResponse resp = getAFCI(); Object obj = new Object(); assertFalse(resp.equals(obj)); } @Test public void isNotEqualsNull() { ApduResponse resp = getAFCI(); ApduResponse respNull = new ApduResponse(null, null); assertFalse(resp.equals(respNull)); }
### Question: ApduResponse implements Serializable { @Override public int hashCode() { int hash = 17; hash = 19 * hash + (this.successful ? 0 : 1); hash = 31 * hash + (bytes == null ? 0 : Arrays.hashCode(bytes)); return hash; } ApduResponse(byte[] buffer, Set<Integer> successfulStatusCodes); boolean isSuccessful(); int getStatusCode(); byte[] getBytes(); byte[] getDataOut(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void hashcodeTest() { ApduResponse resp = getAFCI(); ApduResponse resp2 = getAFCI(); assertTrue(resp.hashCode() == resp2.hashCode()); } @Test public void hashcodeNull() { ApduResponse resp = new ApduResponse(null, null); assertNotNull(resp.hashCode()); }
### Question: ApduResponse implements Serializable { @Override public String toString() { String prefix; if (isSuccessful()) { prefix = "ApduResponse: SUCCESS, RAWDATA = "; } else { prefix = "ApduResponse: FAILURE, RAWDATA = "; } return prefix + ByteArrayUtils.toHex(this.bytes); } ApduResponse(byte[] buffer, Set<Integer> successfulStatusCodes); boolean isSuccessful(); int getStatusCode(); byte[] getBytes(); byte[] getDataOut(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testToStringNull() { ApduResponse resp = new ApduResponse(null, null); assertNotNull(resp.toString()); }
### Question: SeResponse implements Serializable { @Override public boolean equals(Object o) { if (o == this) { return true; } if (!(o instanceof SeResponse)) { return false; } SeResponse seResponse = (SeResponse) o; return seResponse.getSelectionStatus().equals(selectionStatus) && (seResponse.getApduResponses() == null ? apduResponses == null : seResponse.getApduResponses().equals(apduResponses)) && seResponse.isLogicalChannelOpen() == logicalChannelIsOpen && seResponse.wasChannelPreviouslyOpen() == channelPreviouslyOpen; } SeResponse(boolean logicalChannelIsOpen, boolean channelPreviouslyOpen, SelectionStatus selectionStatus, List<ApduResponse> apduResponses); boolean wasChannelPreviouslyOpen(); boolean isLogicalChannelOpen(); SelectionStatus getSelectionStatus(); List<ApduResponse> getApduResponses(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test() public void testEquals() throws Exception { Assert.assertTrue(getASeResponse().equals(getASeResponse())); } @Test() public void testThisEquals() throws Exception { SeResponse resp = getASeResponse(); Assert.assertTrue(resp.equals(resp)); } @Test() public void testNotEquals() throws Exception { SeResponse resp = getASeResponse(); Object any = new Object(); Assert.assertFalse(resp.equals(any)); } @Test() public void testNotEqualsNull() throws Exception { SeResponse resp = getASeResponse(); SeResponse respNull = new SeResponse(true, true, new SelectionStatus(null, ApduResponseTest.getAFCI(), true), null); SeResponse respNull2 = new SeResponse(true, true, new SelectionStatus(ApduResponseTest.getAAtr(), null, true), null); SeResponse respNull3 = new SeResponse(true, true, new SelectionStatus(ApduResponseTest.getAAtr(), ApduResponseTest.getAFCI(), true), null); Assert.assertFalse(resp.equals(respNull)); Assert.assertFalse(resp.equals(respNull2)); Assert.assertFalse(resp.equals(respNull3)); }
### Question: SeResponse implements Serializable { @Override public int hashCode() { int hash = 17; hash = 31 * hash + (selectionStatus.getAtr() == null ? 0 : selectionStatus.getAtr().hashCode()); hash = 7 * hash + (apduResponses == null ? 0 : this.apduResponses.hashCode()); hash = 29 * hash + (this.channelPreviouslyOpen ? 1 : 0); hash = 37 * hash + (this.logicalChannelIsOpen ? 1 : 0); return hash; } SeResponse(boolean logicalChannelIsOpen, boolean channelPreviouslyOpen, SelectionStatus selectionStatus, List<ApduResponse> apduResponses); boolean wasChannelPreviouslyOpen(); boolean isLogicalChannelOpen(); SelectionStatus getSelectionStatus(); List<ApduResponse> getApduResponses(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test() public void hashcode() throws Exception { SeResponse resp = getASeResponse(); SeResponse resp2 = getASeResponse(); Assert.assertTrue(resp.hashCode() == resp2.hashCode()); } @Test() public void hashcodeNull() throws Exception { SeResponse resp = new SeResponse(true, true, new SelectionStatus(null, ApduResponseTest.getAFCI(), true), null); Assert.assertNotNull(resp.hashCode()); }
### Question: SeResponseSet implements Serializable { public SeResponse getSingleResponse() { if (seResponses.size() != 1) { throw new IllegalStateException("This method only support ONE element"); } return seResponses.get(0); } SeResponseSet(List<SeResponse> seResponses); SeResponseSet(SeResponse response); List<SeResponse> getResponses(); SeResponse getSingleResponse(); @Override String toString(); }### Answer: @Test public void getSingleResponse() throws Exception { SeResponseSet set = new SeResponseSet(SeResponseTest.getASeResponse()); assertEquals(SeResponseTest.getASeResponse(), set.getSingleResponse()); } @Test(expected = IllegalStateException.class) public void getSingleResponseFail() throws Exception { List<SeResponse> seResponses = new ArrayList<SeResponse>(); seResponses.add(SeResponseTest.getASeResponse()); seResponses.add(SeResponseTest.getASeResponse()); SeResponseSet set = new SeResponseSet(seResponses); set.getSingleResponse(); }
### Question: SeResponseSet implements Serializable { public List<SeResponse> getResponses() { return seResponses; } SeResponseSet(List<SeResponse> seResponses); SeResponseSet(SeResponse response); List<SeResponse> getResponses(); SeResponse getSingleResponse(); @Override String toString(); }### Answer: @Test public void getResponses() throws Exception { List<SeResponse> seResponses = new ArrayList<SeResponse>(); seResponses.add(SeResponseTest.getASeResponse()); seResponses.add(SeResponseTest.getASeResponse()); SeResponseSet set = new SeResponseSet(seResponses); assertArrayEquals(seResponses.toArray(), set.getResponses().toArray()); }
### Question: SeResponseSet implements Serializable { @Override public String toString() { return seResponses.size() + " SeReponse(s)"; } SeResponseSet(List<SeResponse> seResponses); SeResponseSet(SeResponse response); List<SeResponse> getResponses(); SeResponse getSingleResponse(); @Override String toString(); }### Answer: @Test public void toStringTest() throws Exception { SeResponse emptySeR = new SeResponse(true, true, new SelectionStatus( new AnswerToReset(ByteArrayUtils.fromHex("3BFF00")), null, true), null); SeResponseSet set = new SeResponseSet(emptySeR); assertNotNull(set.toString()); }
### Question: SeProxyService { public static SeProxyService getInstance() { return uniqueInstance; } private SeProxyService(); static SeProxyService getInstance(); void setPlugins(SortedSet<ReaderPlugin> plugins); void addPlugin(ReaderPlugin plugin); SortedSet<ReaderPlugin> getPlugins(); ReaderPlugin getPlugin(String name); String getVersion(); }### Answer: @Test public void testGetInstance() { assertNotNull(proxyService); }
### Question: SeProxyService { public String getVersion() { try { InputStream propertiesIs = this.getClass().getClassLoader() .getResourceAsStream("META-INF/keyple-core.properties"); Properties prop = new Properties(); prop.load(propertiesIs); String version = prop.getProperty("version"); if (version != null) { return version; } } catch (IOException e) { e.printStackTrace(); } return "no-version-found"; } private SeProxyService(); static SeProxyService getInstance(); void setPlugins(SortedSet<ReaderPlugin> plugins); void addPlugin(ReaderPlugin plugin); SortedSet<ReaderPlugin> getPlugins(); ReaderPlugin getPlugin(String name); String getVersion(); }### Answer: @Test public void testGetVersion() { String regex = "^([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?(?:\\+[0-9A-Za-z-]+)?$"; String version = SeProxyService.getInstance().getVersion(); logger.info("Version of SeProxyService {}", version); System.out.println("Version of SeProxyService " + version); assertTrue(version.matches(regex)); }
### Question: SeProxyService { public ReaderPlugin getPlugin(String name) throws KeyplePluginNotFoundException { for (ReaderPlugin plugin : plugins) { if (plugin.getName().equals(name)) { return plugin; } } throw new KeyplePluginNotFoundException(name); } private SeProxyService(); static SeProxyService getInstance(); void setPlugins(SortedSet<ReaderPlugin> plugins); void addPlugin(ReaderPlugin plugin); SortedSet<ReaderPlugin> getPlugins(); ReaderPlugin getPlugin(String name); String getVersion(); }### Answer: @Test public void testGetPlugin() throws KeyplePluginNotFoundException { ConcurrentSkipListSet<ReaderPlugin> plugins = getPluginList(); proxyService.setPlugins(plugins); assertEquals(plugin1, proxyService.getPlugin(PLUGIN_NAME)); }
### Question: ReaderEvent { public ReaderEvent(String pluginName, String readerName, EventType eventType, SelectionResponse selectionResponse) { this.pluginName = pluginName; this.readerName = readerName; this.eventType = eventType; this.defaultResponseSet = selectionResponse; } ReaderEvent(String pluginName, String readerName, EventType eventType, SelectionResponse selectionResponse); String getPluginName(); String getReaderName(); EventType getEventType(); SelectionResponse getDefaultSelectionResponse(); }### Answer: @Test public void testReaderEvent() { ReaderEvent event = new ReaderEvent("plugin", "reader", ReaderEvent.EventType.IO_ERROR, null); assertNotNull(event); }
### Question: AppendRecordRespPars extends AbstractPoResponseParser { public AppendRecordRespPars(ApduResponse response) { super(response); } AppendRecordRespPars(ApduResponse response); }### Answer: @Test public void appendRecordRespPars() { List<ApduResponse> responses = new ArrayList<ApduResponse>(); ApduResponse apduResponse = new ApduResponse(new byte[] {90, 0}, null); responses.add(apduResponse); SeResponseSet seResponse = new SeResponseSet(new SeResponse(true, true, new SelectionStatus(null, new ApduResponse(ByteArrayUtils.fromHex("9000"), null), true), responses)); AbstractApduResponseParser apduResponseParser = new AppendRecordRespPars(seResponse.getSingleResponse().getApduResponses().get(0)); Assert.assertArrayEquals(new byte[] {90, 0}, apduResponseParser.getApduResponse().getBytes()); }
### Question: UpdateRecordRespPars extends AbstractPoResponseParser { public UpdateRecordRespPars(ApduResponse response) { super(response); } UpdateRecordRespPars(ApduResponse response); }### Answer: @Test public void updateRecordRespPars() { List<ApduResponse> responses = new ArrayList<ApduResponse>(); ApduResponse apduResponse = new ApduResponse(new byte[] {90, 00}, null); responses.add(apduResponse); SeResponseSet seResponse = new SeResponseSet(new SeResponse(true, true, new SelectionStatus(null, new ApduResponse(ByteArrayUtils.fromHex("9000"), null), true), responses)); AbstractApduResponseParser apduResponseParser = new UpdateRecordRespPars(seResponse.getSingleResponse().getApduResponses().get(0)); Assert.assertArrayEquals(new byte[] {90, 0}, apduResponseParser.getApduResponse().getBytes()); }
### Question: CloseSessionRespPars extends AbstractApduResponseParser { public CloseSessionRespPars(ApduResponse response) { super(response); parse(response.getDataOut()); } CloseSessionRespPars(ApduResponse response); byte[] getSignatureLo(); byte[] getPostponedData(); }### Answer: @Test public void closeSessionRespPars() { byte[] response = {0x4D, (byte) 0xBD, (byte) 0xC9, 0x60, (byte) 0x90, 0x00}; List<ApduResponse> responses = new ArrayList<ApduResponse>(); ApduResponse apduResponse = new ApduResponse(response, null); responses.add(apduResponse); SeResponseSet seResponse = new SeResponseSet(new SeResponse(true, true, new SelectionStatus(null, new ApduResponse(ByteArrayUtils.fromHex("9000"), null), true), responses)); AbstractApduResponseParser apduResponseParser = new CloseSessionRespPars(seResponse.getSingleResponse().getApduResponses().get(0)); Assert.assertArrayEquals(response, apduResponseParser.getApduResponse().getBytes()); }
### Question: CloseSessionRespPars extends AbstractApduResponseParser { public byte[] getSignatureLo() { return signatureLo; } CloseSessionRespPars(ApduResponse response); byte[] getSignatureLo(); byte[] getPostponedData(); }### Answer: @Test public void TestToPOHalfSessionSignature() { byte[] apduResponse = new byte[] {(byte) 0x4D, (byte) 0xBD, (byte) 0xC9, 0x60, (byte) 0x90, 0x00}; byte[] apduResponseCaseTwo = new byte[] {(byte) 0xA8, 0x31, (byte) 0xC3, 0x3E, (byte) 0xA7, 0x21, (byte) 0xC2, 0x2E, (byte) 0x90, 0x00}; byte[] apduResponseCaseThree = new byte[] {(byte) 0xA8, 0x31, (byte) 0xC3, (byte) 0x90, 0x00}; byte[] sessionSignature = new byte[] {(byte) 0x4D, (byte) 0xBD, (byte) 0xC9, 0x60}; byte[] sessionSignatureCaseTwo = new byte[] {(byte) 0xA7, 0x21, (byte) 0xC2, 0x2E}; { CloseSessionRespPars pars = new CloseSessionRespPars(new ApduResponse(apduResponse, null)); Assert.assertArrayEquals(sessionSignature, pars.getSignatureLo()); } { CloseSessionRespPars pars = new CloseSessionRespPars(new ApduResponse(apduResponseCaseTwo, null)); Assert.assertArrayEquals(sessionSignatureCaseTwo, pars.getSignatureLo()); } { try { CloseSessionRespPars pars = new CloseSessionRespPars(new ApduResponse(apduResponseCaseThree, null)); Assert.fail(); } catch (IllegalArgumentException ex) { } } }
### Question: CalypsoPo extends MatchingSe { public PoRevision getRevision() { return this.revision; } CalypsoPo(SeResponse selectionResponse, String extraInfo); PoRevision getRevision(); byte[] getDfName(); byte[] getApplicationSerialNumber(); byte[] getAtr(); boolean isModificationsCounterInBytes(); int getModificationsCounter(); PoClass getPoClass(); }### Answer: @Test public void computePoRevision() { Assert.assertEquals(getPoApplicationByte((byte) 0x01).getRevision(), PoRevision.REV2_4); Assert.assertEquals(getPoApplicationByte((byte) 0x04).getRevision(), PoRevision.REV2_4); Assert.assertEquals(getPoApplicationByte((byte) 0x06).getRevision(), PoRevision.REV2_4); Assert.assertEquals(getPoApplicationByte((byte) 0x1F).getRevision(), PoRevision.REV2_4); Assert.assertEquals(getPoApplicationByte((byte) 0x20).getRevision(), PoRevision.REV3_1); Assert.assertEquals(getPoApplicationByte((byte) 0x27).getRevision(), PoRevision.REV3_1); Assert.assertEquals(getPoApplicationByte((byte) 0x28).getRevision(), PoRevision.REV3_2); Assert.assertEquals(getPoApplicationByte((byte) 0x2F).getRevision(), PoRevision.REV3_2); }
### Question: TagProxy implements TagTechnology { @Override public Tag getTag() { return tagTechnology.getTag(); } private TagProxy(TagTechnology tagTechnology, String tech); @Override Tag getTag(); @Override void connect(); @Override void close(); @Override boolean isConnected(); }### Answer: @Test(expected = Test.None.class ) public void getTag() throws KeypleReaderException, IOException { TagProxy tagProxy = TagProxy.getTagProxy(tagIso); }
### Question: TagProxy implements TagTechnology { @Override public void connect() throws IOException { tagTechnology.connect(); } private TagProxy(TagTechnology tagTechnology, String tech); @Override Tag getTag(); @Override void connect(); @Override void close(); @Override boolean isConnected(); }### Answer: @Test(expected = Test.None.class ) public void connect() throws KeypleReaderException, IOException { TagProxy tagProxy = TagProxy.getTagProxy(tagIso); tagProxy.connect(); }
### Question: TagProxy implements TagTechnology { @Override public void close() throws IOException { tagTechnology.close(); } private TagProxy(TagTechnology tagTechnology, String tech); @Override Tag getTag(); @Override void connect(); @Override void close(); @Override boolean isConnected(); }### Answer: @Test(expected = Test.None.class ) public void close() throws KeypleReaderException, IOException { TagProxy tagProxy = TagProxy.getTagProxy(tagIso); tagProxy.close(); }
### Question: TagProxy implements TagTechnology { @Override public boolean isConnected() { return tagTechnology.isConnected(); } private TagProxy(TagTechnology tagTechnology, String tech); @Override Tag getTag(); @Override void connect(); @Override void close(); @Override boolean isConnected(); }### Answer: @Test(expected = Test.None.class ) public void isConnected() throws KeypleReaderException, IOException { TagProxy tagProxy = TagProxy.getTagProxy(tagIso); tagProxy.isConnected(); }
### Question: TagProxy implements TagTechnology { byte[] transceive(byte[] data) throws IOException { if (tech.equals(AndroidNfcProtocolSettings.ProtocolSetting.NFC_TAG_TYPE_MIFARE_CLASSIC)) { return ((MifareClassic) tagTechnology).transceive(data); } else if (tech.equals(AndroidNfcProtocolSettings.ProtocolSetting.NFC_TAG_TYPE_MIFARE_UL)) { return ((MifareUltralight) tagTechnology).transceive(data); } else if (tech.equals(AndroidNfcProtocolSettings.ProtocolSetting.NFC_TAG_TYPE_ISODEP)) { return ((IsoDep) tagTechnology).transceive(data); } else { return null; } } private TagProxy(TagTechnology tagTechnology, String tech); @Override Tag getTag(); @Override void connect(); @Override void close(); @Override boolean isConnected(); }### Answer: @Test(expected = Test.None.class ) public void transceive() throws KeypleReaderException, IOException { TagProxy tagProxy = TagProxy.getTagProxy(tagIso); tagProxy.transceive("0000".getBytes()); }
### Question: AndroidNfcPlugin extends AbstractStaticPlugin { public static AndroidNfcPlugin getInstance() { return uniqueInstance; } private AndroidNfcPlugin(); static AndroidNfcPlugin getInstance(); @Override Map<String, String> getParameters(); @Override void setParameter(String key, String value); }### Answer: @Test public void getInstance() throws IOException { Assert.assertTrue(plugin != null); }
### Question: AndroidNfcPlugin extends AbstractStaticPlugin { @Override public Map<String, String> getParameters() { LOG.warn("Android NFC Plugin does not support parameters, see AndroidNfcReader instead"); return parameters; } private AndroidNfcPlugin(); static AndroidNfcPlugin getInstance(); @Override Map<String, String> getParameters(); @Override void setParameter(String key, String value); }### Answer: @Test public void setParameters() throws KeypleBaseException { Map<String, String> parameters = new HashMap<String, String>(); parameters.put("key1", "value1"); plugin.setParameters(parameters); Assert.assertTrue(plugin.getParameters().size() > 0); Assert.assertTrue(plugin.getParameters().get("key1").equals("value1")); } @Test public void getParameters() throws IOException { Assert.assertTrue(plugin.getParameters() != null); }
### Question: AndroidNfcPlugin extends AbstractStaticPlugin { @Override public void setParameter(String key, String value) { LOG.warn("Android NFC Plugin does not support parameters, see AndroidNfcReader instead"); parameters.put(key, value); } private AndroidNfcPlugin(); static AndroidNfcPlugin getInstance(); @Override Map<String, String> getParameters(); @Override void setParameter(String key, String value); }### Answer: @Test public void setParameter() throws IOException { plugin.setParameter("key2", "value2"); Assert.assertTrue(plugin.getParameters().size() > 0); Assert.assertTrue(plugin.getParameters().get("key2").equals("value2")); }
### Question: AndroidNfcReader extends AbstractSelectionLocalReader implements NfcAdapter.ReaderCallback { @Override protected boolean checkSePresence() { return tagProxy != null && tagProxy.isConnected(); } AndroidNfcReader(); Map<String, String> getParameters(); @Override void setParameter(String key, String value); @Override TransmissionMode getTransmissionMode(); @Override void onTagDiscovered(Tag tag); String printTagId(); static final String FLAG_READER_SKIP_NDEF_CHECK; static final String FLAG_READER_NO_PLATFORM_SOUNDS; static final String FLAG_READER_PRESENCE_CHECK_DELAY; }### Answer: @Test public void isConnected() { insertSe(); when(tagProxy.isConnected()).thenReturn(true); assertEquals(true, reader.checkSePresence()); }
### Question: AndroidNfcReader extends AbstractSelectionLocalReader implements NfcAdapter.ReaderCallback { @Override protected byte[] getATR() { byte[] atr = tagProxy.getATR(); LOG.debug("ATR : " + Arrays.toString(atr)); return atr != null && atr.length > 0 ? atr : null; } AndroidNfcReader(); Map<String, String> getParameters(); @Override void setParameter(String key, String value); @Override TransmissionMode getTransmissionMode(); @Override void onTagDiscovered(Tag tag); String printTagId(); static final String FLAG_READER_SKIP_NDEF_CHECK; static final String FLAG_READER_NO_PLATFORM_SOUNDS; static final String FLAG_READER_PRESENCE_CHECK_DELAY; }### Answer: @Test public void getATR() { insertSe(); byte[] atr = new byte[] {(byte) 0x90, 0x00}; when(tagProxy.getATR()).thenReturn(atr); assertEquals(atr, reader.getATR()); }
### Question: AndroidNfcReader extends AbstractSelectionLocalReader implements NfcAdapter.ReaderCallback { @Override protected boolean isPhysicalChannelOpen() { return tagProxy != null && tagProxy.isConnected(); } AndroidNfcReader(); Map<String, String> getParameters(); @Override void setParameter(String key, String value); @Override TransmissionMode getTransmissionMode(); @Override void onTagDiscovered(Tag tag); String printTagId(); static final String FLAG_READER_SKIP_NDEF_CHECK; static final String FLAG_READER_NO_PLATFORM_SOUNDS; static final String FLAG_READER_PRESENCE_CHECK_DELAY; }### Answer: @Test public void isPhysicalChannelOpen() { insertSe(); when(tagProxy.isConnected()).thenReturn(true); assertEquals(true, reader.isPhysicalChannelOpen()); }
### Question: AndroidNfcReader extends AbstractSelectionLocalReader implements NfcAdapter.ReaderCallback { @Override protected void openPhysicalChannel() throws KeypleChannelStateException { if (!checkSePresence()) { try { LOG.debug("Connect to tag.."); tagProxy.connect(); LOG.info("Tag connected successfully : " + printTagId()); } catch (IOException e) { LOG.error("Error while connecting to Tag "); e.printStackTrace(); throw new KeypleChannelStateException("Error while opening physical channel", e); } } else { LOG.info("Tag is already connected to : " + printTagId()); } } AndroidNfcReader(); Map<String, String> getParameters(); @Override void setParameter(String key, String value); @Override TransmissionMode getTransmissionMode(); @Override void onTagDiscovered(Tag tag); String printTagId(); static final String FLAG_READER_SKIP_NDEF_CHECK; static final String FLAG_READER_NO_PLATFORM_SOUNDS; static final String FLAG_READER_PRESENCE_CHECK_DELAY; }### Answer: @Test public void openPhysicalChannelSuccess() throws KeypleReaderException { insertSe(); when(tagProxy.isConnected()).thenReturn(false); reader.openPhysicalChannel(); } @Test(expected = KeypleReaderException.class) public void openPhysicalChannelError() throws KeypleBaseException, IOException { insertSe(); when(tagProxy.isConnected()).thenReturn(false); doThrow(new IOException()).when(tagProxy).connect(); reader.openPhysicalChannel(); }
### Question: MatchingResources { @Override public String toString() { StringBuilder sb = new StringBuilder(); for (Resource r : resources) { if (sb.length() > 0) sb.append('\n'); sb.append(getURL(r).toString()); } return sb.toString(); } MatchingResources(String sPattern); Resource[] getAllMatches(); URL[] getAllMatchesURL(); List<Class<?>> getAnnotatedMatches(Class<? extends Annotation> annotation, boolean includeSubclasses); List<Class<?>> getAnnotatedMatches(Class<? extends Annotation> annotation); Resource getSingleResource(); URL getSingleResourceURL(); Resource getSingleRequiredResource(); URL getSingleRequiredResourceURL(); URL getURL(Resource r); @Override String toString(); }### Answer: @Test public void testToString() { MatchingResources mr = new MatchingResources("classpath*:org/wicketstuff/config/*.class"); assertTrue(mr.getAllMatches().length > 0); logger.info("URLs:\n" + mr); }
### Question: DateTimeField extends FormComponentPanel<Date> { public final Integer getHours() { return hours; } DateTimeField(final String id); DateTimeField(final String id, final IModel<Date> model); final AM_PM getAmOrPm(); final Date getDate(); final Integer getHours(); final Integer getMinutes(); @Override String getInput(); final void setAmOrPm(final AM_PM amOrPm); final void setDate(final Date date); final void setHours(final Integer hours); final void setMinutes(final Integer minutes); @Override void convertInput(); static Date changeTimeZone(Date date, TimeZone zone); }### Answer: @Test public void testTimeZones() { DateTimeZone defaultTimeZone = DateTimeZone.getDefault(); try { DateTimeZone.setDefault(DateTimeZone.forID("UTC")); final String clientTimezone = "America/Toronto"; DateTime jan01_10am = new DateTime(2013, 01, 01, 10, 0, 0, DateTimeZone.forID(clientTimezone)); DateTimeField dateTimeField = new DateTimeField("foo", Model.of(jan01_10am.toDate())) { private static final long serialVersionUID = 1L; @Override protected TimeZone getClientTimeZone() { return TimeZone.getTimeZone(clientTimezone); } }; tester.startComponentInPage(dateTimeField); assertEquals(jan01_10am.getHourOfDay(), dateTimeField.getHours().intValue(), "The hour of day is incorrect!"); } finally { DateTimeZone.setDefault(defaultTimeZone); } }
### Question: TreeTransformator extends AbstractTreeTransformingProcessor { public static IFilter strip(ITreeFilter filter) { return new Filter(FilterType.STRIP,filter); } TreeTransformator(ISerializedObjectTreeProcessor destination, IFilter... filter); static IFilter strip(ITreeFilter filter); static IFilter compact(ITreeFilter filter); }### Answer: @Test public void removeAllCNodes() throws IOException { ISerializedObjectTree tree = Trees.fromResource(getClass(), "treeOf3"); ISerializedObjectTree filtered = TreeTransformations.strip(tree, new NotDepth(3)); ISerializedObjectTree expected = Trees.fromResource(getClass(), "treeOf3-noDepth3"); Trees.assertEqualsTree(expected, filtered); } @Test public void canNotRemoveANodes() throws IOException { assertThrows(IllegalArgumentException.class, () -> { ISerializedObjectTree tree = Trees.fromResource(getClass(), "treeOf3"); ISerializedObjectTree filtered = TreeTransformations.strip(tree, new NotDepth(0)); }); } @Test public void removeAllBNodes() throws IOException { ISerializedObjectTree tree = Trees.fromResource(getClass(), "treeOf3"); ISerializedObjectTree filtered = TreeTransformations.strip(tree, new NotDepth(2)); ISerializedObjectTree expected = Trees.fromResource(getClass(), "treeOf3-noDepth2"); Trees.assertEqualsTree(expected, filtered); }
### Question: StringUtil { public static String EnumNameToCssClassName(String name) { Args.notNull(name, "name"); return name.replace("_", "-").toLowerCase(); } static String EnumNameToCssClassName(String name); }### Answer: @Test public void testEnumNameToCssClassNameNull() { assertThrows(IllegalArgumentException.class, () -> { StringUtil.EnumNameToCssClassName(null); }); } @Test public void testEnumNameToCssClassName() { assertEquals("show-for-xxlarge-up", StringUtil.EnumNameToCssClassName("SHOW_FOR_XXLARGE_UP")); assertEquals("abc123", StringUtil.EnumNameToCssClassName("ABC123")); }
### Question: Attribute { public static ComponentTag setClass(ComponentTag tag, String className) { Args.notNull(tag, "tag"); Args.notNull(className, "className"); tag.put("class", className); return tag; } static ComponentTag setClass(ComponentTag tag, String className); static ComponentTag addClass(ComponentTag tag, String className); static ComponentTag removeClass(ComponentTag tag, String className); static boolean hasClass(ComponentTag tag, String className); static ComponentTag addAttribute(ComponentTag tag, String attribute); static ComponentTag addAttribute(ComponentTag tag, String attribute, String value); static ComponentTag addAttribute(ComponentTag tag, String attribute, boolean value); static ComponentTag addAttribute(ComponentTag tag, String attribute, int value); static ComponentTag removeAttribute(ComponentTag tag, String attribute); static boolean hasAttribute(ComponentTag tag, String attribute); static String getAttribute(ComponentTag tag, String attribute); static ComponentTag setDataOptions(ComponentTag tag, String value); static ComponentTag addDataOptions(ComponentTag tag, String value); static ComponentTag removeDataOptions(ComponentTag tag, String value); static boolean hasDataOptions(ComponentTag tag, String value); static String removeToken(String attribute, String remove, String separator); }### Answer: @Test public void testSetClass() { final ComponentTag tag = new ComponentTag("div", XmlTag.TagType.OPEN_CLOSE); assertEquals(null, tag.getAttribute("class")); Attribute.setClass(tag, "pink"); assertEquals("pink", tag.getAttribute("class")); Attribute.setClass(tag, "blue"); assertEquals("blue", tag.getAttribute("class")); }
### Question: TreeTypeMap { protected static String allLables(List<? extends ISerializedObjectTree> list) { Set<String> labels = new LinkedHashSet<String>(); for (ISerializedObjectTree t : list) { if (t.label() != null) labels.add(t.label()); } if (labels.isEmpty()) { return null; } StringBuilder sb = new StringBuilder(); boolean first = true; for (String s : labels) { if (first) { first = false; } else { sb.append("|"); } sb.append(s); } return sb.toString(); } TreeTypeMap(List<? extends ISerializedObjectTree> source); List<ISerializedObjectTree> compressedResult(); boolean hasLessEntries(int size); }### Answer: @Test public void joinLabels() throws IOException { ISerializedObjectTree source = Trees.fromResource(getClass(), "labels"); assertEquals("a|b|c", TreeTypeMap.allLables(source.children())); } @Test public void noLabels() throws IOException { assertEquals(null, TreeTypeMap.allLables(new ArrayList<ISerializedObjectTree>())); }
### Question: Attribute { public static ComponentTag addClass(ComponentTag tag, String className) { Args.notNull(tag, "tag"); Args.notNull(className, "className"); if (!hasClass(tag, className)) { String value = tag.getAttribute("class"); if (value == null) { tag.put("class", className); } else { tag.put("class", value + " " + className); } } return tag; } static ComponentTag setClass(ComponentTag tag, String className); static ComponentTag addClass(ComponentTag tag, String className); static ComponentTag removeClass(ComponentTag tag, String className); static boolean hasClass(ComponentTag tag, String className); static ComponentTag addAttribute(ComponentTag tag, String attribute); static ComponentTag addAttribute(ComponentTag tag, String attribute, String value); static ComponentTag addAttribute(ComponentTag tag, String attribute, boolean value); static ComponentTag addAttribute(ComponentTag tag, String attribute, int value); static ComponentTag removeAttribute(ComponentTag tag, String attribute); static boolean hasAttribute(ComponentTag tag, String attribute); static String getAttribute(ComponentTag tag, String attribute); static ComponentTag setDataOptions(ComponentTag tag, String value); static ComponentTag addDataOptions(ComponentTag tag, String value); static ComponentTag removeDataOptions(ComponentTag tag, String value); static boolean hasDataOptions(ComponentTag tag, String value); static String removeToken(String attribute, String remove, String separator); }### Answer: @Test public void testAddClass() { final ComponentTag tag = new ComponentTag("div", XmlTag.TagType.OPEN_CLOSE); assertEquals(null, tag.getAttribute("class")); Attribute.addClass(tag, "pink"); assertEquals("pink", tag.getAttribute("class")); Attribute.addClass(tag, "blue"); assertEquals("pink blue", tag.getAttribute("class")); Attribute.addClass(tag, "blue"); assertEquals("pink blue", tag.getAttribute("class")); }
### Question: Attribute { public static boolean hasClass(ComponentTag tag, String className) { Args.notNull(tag, "tag"); String value = tag.getAttribute("class"); if (value == null) { return false; } String[] existing = value.split(" "); return Arrays.asList(existing).contains(className); } static ComponentTag setClass(ComponentTag tag, String className); static ComponentTag addClass(ComponentTag tag, String className); static ComponentTag removeClass(ComponentTag tag, String className); static boolean hasClass(ComponentTag tag, String className); static ComponentTag addAttribute(ComponentTag tag, String attribute); static ComponentTag addAttribute(ComponentTag tag, String attribute, String value); static ComponentTag addAttribute(ComponentTag tag, String attribute, boolean value); static ComponentTag addAttribute(ComponentTag tag, String attribute, int value); static ComponentTag removeAttribute(ComponentTag tag, String attribute); static boolean hasAttribute(ComponentTag tag, String attribute); static String getAttribute(ComponentTag tag, String attribute); static ComponentTag setDataOptions(ComponentTag tag, String value); static ComponentTag addDataOptions(ComponentTag tag, String value); static ComponentTag removeDataOptions(ComponentTag tag, String value); static boolean hasDataOptions(ComponentTag tag, String value); static String removeToken(String attribute, String remove, String separator); }### Answer: @Test public void testHasClass() { final ComponentTag tag = new ComponentTag("div", XmlTag.TagType.OPEN_CLOSE); Attribute.setClass(tag, "pink green blue"); assertTrue(Attribute.hasClass(tag, "pink")); assertTrue(Attribute.hasClass(tag, "green")); assertTrue(Attribute.hasClass(tag, "blue")); assertFalse(Attribute.hasClass(tag, "black")); }
### Question: Attribute { public static ComponentTag removeClass(ComponentTag tag, String className) { Args.notNull(tag, "tag"); Args.notNull(className, "className"); if (hasClass(tag, className)) { tag.put("class", removeToken(tag.getAttribute("class"), className, " ")); } return tag; } static ComponentTag setClass(ComponentTag tag, String className); static ComponentTag addClass(ComponentTag tag, String className); static ComponentTag removeClass(ComponentTag tag, String className); static boolean hasClass(ComponentTag tag, String className); static ComponentTag addAttribute(ComponentTag tag, String attribute); static ComponentTag addAttribute(ComponentTag tag, String attribute, String value); static ComponentTag addAttribute(ComponentTag tag, String attribute, boolean value); static ComponentTag addAttribute(ComponentTag tag, String attribute, int value); static ComponentTag removeAttribute(ComponentTag tag, String attribute); static boolean hasAttribute(ComponentTag tag, String attribute); static String getAttribute(ComponentTag tag, String attribute); static ComponentTag setDataOptions(ComponentTag tag, String value); static ComponentTag addDataOptions(ComponentTag tag, String value); static ComponentTag removeDataOptions(ComponentTag tag, String value); static boolean hasDataOptions(ComponentTag tag, String value); static String removeToken(String attribute, String remove, String separator); }### Answer: @Test public void testRemoveClass() { final ComponentTag tag = new ComponentTag("div", XmlTag.TagType.OPEN_CLOSE); Attribute.setClass(tag, "pink blue red"); assertTrue(Attribute.hasClass(tag, "pink")); assertTrue(Attribute.hasClass(tag, "blue")); assertTrue(Attribute.hasClass(tag, "red")); Attribute.removeClass(tag, "pink"); assertFalse(Attribute.hasClass(tag, "pink")); assertTrue(Attribute.hasClass(tag, "blue")); assertTrue(Attribute.hasClass(tag, "red")); Attribute.removeClass(tag, "red"); assertTrue(Attribute.hasClass(tag, "blue")); assertFalse(Attribute.hasClass(tag, "red")); Attribute.removeClass(tag, "blue"); assertFalse(Attribute.hasClass(tag, "blue")); assertEquals("", tag.getAttribute("class")); }
### Question: FoundationTab extends TabbedPanel<T> { public FoundationTab<T> setVerticalTab(boolean verticalTab) { this.verticalTab = verticalTab; return this; } FoundationTab(String id, List<T> tabs); FoundationTab(String id, List<T> tabs, IModel<Integer> model); boolean isVerticalTab(); FoundationTab<T> setVerticalTab(boolean verticalTab); }### Answer: @Test public void renderSimpleTab() throws Exception { FoundationTab<ITab> tab = new FoundationTab<>("id", tabs); tester.startComponentInPage(tab); testRenderedTab(); tab = new FoundationTab<>("id", tabs); tester.startComponentInPage(tab.setVerticalTab(true)); TagTester tagByWicketId = tester.getTagByWicketId("tabs-container"); assertTrue(tagByWicketId.getAttributeContains("class", "vertical")); }
### Question: FoundationOrbitSlider extends OrbitSliderBase { public FoundationOrbitSlider(String id, IModel<List<OrbitSliderItem>> itemsModel) { super(id, itemsModel); } FoundationOrbitSlider(String id, IModel<List<OrbitSliderItem>> itemsModel); }### Answer: @Test public void testFoundationOrbitSlider() { WicketTester tester = new WicketTester(); List<OrbitSliderItem> items = new ArrayList<>(); items.add(new OrbitSliderItem("1", new PackageResourceReference(this.getClass(), "andromeda-orbit.jpg"), "Caption 1")); items.add(new OrbitSliderItem("2", new PackageResourceReference(this.getClass(), "launch-orbit.jpg"), "Caption 2")); items.add(new OrbitSliderItem("3", new PackageResourceReference(this.getClass(), "satelite-orbit.jpg"), "Caption 3")); FoundationOrbitSlider orbitSlider = new FoundationOrbitSlider("foobar", new ListModel<>(items)); tester.startComponentInPage(orbitSlider); tester.debugComponentTrees(); tester.dumpPage(); assertTrue(tester.getTagByWicketId("container").hasAttribute("data-orbit")); assertEquals(3, tester.getTagsByWicketId("img").size()); assertEquals(3, tester.getTagsByWicketId("captionContainer").size()); assertEquals(3, tester.getTagsByWicketId("caption").size()); }
### Question: KryoSerializer implements ISerializer { @Override public byte[] serialize(final Object object) { LOG.debug("Going to serialize: '{}'", object); try (Output buffer = getBuffer(object)) { getKryo().writeClassAndObject(buffer, object); byte[] data = buffer.toBytes(); if (data == null) { LOG.error("Kryo wasn't able to serialize: '{}'", object); } buffer.reset(); return data; } finally { System.runFinalization(); } } KryoSerializer(); KryoSerializer(final Bytes bufferSize); @Override byte[] serialize(final Object object); @Override Object deserialize(byte[] data); }### Answer: @Test public void notSerializableCompontentThrowsException() { assertThrows(KryoException.class, () -> { NotSerializablePage page = tester.startPage(NotSerializablePage.class, new PageParameters().add("Test", "asString")); tester.assertRenderedPage(NotSerializablePage.class); ISerializer pageSerializer = getAndCheckSerializer(); byte[] data = pageSerializer.serialize(page); }); }
### Question: SpringReference extends AbstractSpringReference<T> implements IClusterable { public static <T> SpringReference<T> of(Class<T> clazz) { return of(clazz, null); } SpringReference(Class<T> clazz, String name); static SpringReference<T> of(Class<T> clazz); static SpringReference<T> of(Class<T> clazz, String name); @Override SpringReference<T> clone(); }### Answer: @Test public void classOnlyTest() { SpringReference<ClassService> reference = SpringReference.of(ClassService.class); testReference(reference, 1); } @Test public void nameAndClassTest() { SpringReference<PrimaryService> reference = SpringReference.of(PrimaryService.class, "named"); testReference(reference, 2); } @Test public void primaryTest() { SpringReference<PrimaryService> reference = SpringReference.of(PrimaryService.class); testReference(reference, 3); } @Test public void autowireTest() { SpringReference<AutowireService> reference = SpringReference.of(AutowireService.class); testReference(reference, 6); } @Test public void constructorTest() { SpringReference<ConstructorService> reference = SpringReference.of(ConstructorService.class); testReference(reference, 4); } @Test public void subClass1Test() { SpringReference<AService> reference = SpringReference.of(AService.class, "named"); testReference(reference, 2); } @Test public void subClass2Test() { SpringReference<AService> reference = SpringReference.of(AService.class); testReference(reference, 3); } @Test public void lazyTest() { SpringReference<AService> reference = SpringReference.of(AService.class, "not-existing-bean-id"); try { testReference(reference, -1); throw new IllegalStateException("Not exsisting spring bean found."); } catch (NoSuchBeanDefinitionException e) { } }
### Question: PolicyFileHiveFactory implements HiveFactory { public final boolean addPolicyFile(URL file) { if (file == null) { log.warn("Can not add null as an url."); return false; } return policyFiles.add(file); } PolicyFileHiveFactory(ActionFactory actionFactory); final boolean addPolicyFile(URL file); final boolean addStream(InputStream stream); final boolean addReader(Reader input); final String getAlias(String key); final String setAlias(String key, String value); final Hive createHive(); final boolean isUsingHiveCache(); final void useHiveCache(boolean useCache); final boolean isCloseInputStreams(); final void setCloseInputStreams(boolean closeInputStreams); }### Answer: @Test public void testAddPolicyFile() { PolicyFileHiveFactory factory = new PolicyFileHiveFactory(Actions.getActionFactory(KEY)); factory.addPolicyFile(getClass().getResource("test-policy.hive")); try { factory.addPolicyFile(new URL("http", "localhost", "foobar")); } catch (MalformedURLException e) { fail(e.getMessage()); } factory.addPolicyFile(null); }
### Question: PolicyFileHiveFactory implements HiveFactory { public final Hive createHive() { BasicHive hive = constructHive(); boolean readAnything = false; for (URL file : policyFiles) { readAnything = true; try { readPolicyFile(file, hive); } catch (IOException e) { log.error("Could not read from " + file, e); } } for (InputStream stream : inputStreams) { readAnything = true; try { readInputStream(stream, hive); } catch (IOException e) { log.error("Could not read from stream", e); } } inputStreams.clear(); for (Reader stream : inputReaders) { readAnything = true; try { readInputReader(stream, hive); } catch (IOException e) { log.error("Could not read from reader", e); } } inputReaders.clear(); if (!readAnything) log.warn("No policyFiles or inputstreams were added to the factory!"); hive.lock(); return hive; } PolicyFileHiveFactory(ActionFactory actionFactory); final boolean addPolicyFile(URL file); final boolean addStream(InputStream stream); final boolean addReader(Reader input); final String getAlias(String key); final String setAlias(String key, String value); final Hive createHive(); final boolean isUsingHiveCache(); final void useHiveCache(boolean useCache); final boolean isCloseInputStreams(); final void setCloseInputStreams(boolean closeInputStreams); }### Answer: @Test public void testCreateHive() { PolicyFileHiveFactory factory = new PolicyFileHiveFactory(Actions.getActionFactory(KEY)); factory.addPolicyFile(getClass().getResource("test-policy.hive")); doCreateHive(factory); }
### Question: ManyToManyMap { public boolean remove(L left, R right) { Set<R> rights = lToRMappings.get(left); if (rights != null) { if (rights.remove(right)) { if (rights.isEmpty()) lToRMappings.remove(left); Set<L> lefts = rToLMappings.get(right); lefts.remove(left); if (lefts.isEmpty()) rToLMappings.remove(right); return true; } } return false; } ManyToManyMap(); ManyToManyMap(int initialCapacity); ManyToManyMap(int initialCapacity, float loadFactor); void add(L left, R right); boolean remove(L left, R right); Set<R> removeAllMappingsForLeft(L left); Set<L> removeAllMappingsForRight(R right); Set<R> getRight(L left); Set<L> getLeft(R right); int size(); int numberOfmappingsForLeft(L left); int numberOfmappingsForRight(R right); boolean containsLeft(L left); boolean containsRight(R right); boolean isEmpty(); void clear(); Iterator<L> leftIterator(); Iterator<R> rightIterator(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testRemove() { ManyToManyMap<String, String> map = new ManyToManyMap<String, String>(); map.add("A.1", "A"); map.add("A.2", "A"); assertEquals(3, map.size()); assertTrue(map.remove("A.1", "A")); assertEquals(2, map.size()); map.add("A.1", "A"); assertEquals(3, map.size()); map = new ManyToManyMap<String, String>(); map.add("A.1", "A"); assertEquals(2, map.size()); map.remove("A.1", "A"); assertEquals(0, map.size()); assertTrue(map.isEmpty()); }
### Question: ManyToManyMap { public int size() { return lToRMappings.size() + rToLMappings.size(); } ManyToManyMap(); ManyToManyMap(int initialCapacity); ManyToManyMap(int initialCapacity, float loadFactor); void add(L left, R right); boolean remove(L left, R right); Set<R> removeAllMappingsForLeft(L left); Set<L> removeAllMappingsForRight(R right); Set<R> getRight(L left); Set<L> getLeft(R right); int size(); int numberOfmappingsForLeft(L left); int numberOfmappingsForRight(R right); boolean containsLeft(L left); boolean containsRight(R right); boolean isEmpty(); void clear(); Iterator<L> leftIterator(); Iterator<R> rightIterator(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testSize() { ManyToManyMap<String, String> map = new ManyToManyMap<String, String>(); assertEquals(0, map.size()); map.add("A.1", "A"); map.add("A.2", "A"); assertEquals(3, map.size()); }