src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
AmazonWebServiceClient { @Deprecated protected Signer getSigner() { return signerProvider.getSigner(SignerProviderContext.builder().build()); } AmazonWebServiceClient(ClientConfiguration clientConfiguration); AmazonWebServiceClient(ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector); @SdkProtectedApi protected AmazonWebServiceClient(ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector,
boolean disableStrictHostNameVerification); protected AmazonWebServiceClient(AwsSyncClientParams clientParams); @Deprecated void setEndpoint(String endpoint); Signer getSignerByURI(URI uri); @Deprecated void setRegion(Region region); @Deprecated final void configureRegion(Regions region); void shutdown(); @Deprecated void addRequestHandler(RequestHandler requestHandler); @Deprecated void addRequestHandler(RequestHandler2 requestHandler2); @Deprecated void removeRequestHandler(RequestHandler requestHandler); @Deprecated void removeRequestHandler(RequestHandler2 requestHandler2); void setTimeOffset(int timeOffset); AmazonWebServiceClient withTimeOffset(int timeOffset); int getTimeOffset(); RequestMetricCollector getRequestMetricsCollector(); String getServiceName(); String getEndpointPrefix(); final void setServiceNameIntern(String serviceName); final String getSignerRegionOverride(); final void setSignerRegionOverride(String signerRegionOverride); @Deprecated T withRegion(Region region); @Deprecated T withRegion(Regions region); @Deprecated T withEndpoint(String endpoint); @Deprecated @SdkInternalApi final void makeImmutable(); String getSignerOverride(); ClientConfiguration getClientConfiguration(); @Deprecated
static final boolean LOGGING_AWS_REQUEST_METRIC; } | @Test public void testOverrideSigner() { ClientConfiguration config = new ClientConfiguration(); config.setSignerOverride("QueryStringSignerType"); AmazonTestClient client = new AmazonTestClient(config); Assert.assertTrue(client.getSigner() instanceof QueryStringSigner); } |
AmazonWebServiceClient { public final void setServiceNameIntern(String serviceName) { if (serviceName == null) throw new IllegalArgumentException( "The parameter serviceName must be specified!"); this.serviceName = serviceName; } AmazonWebServiceClient(ClientConfiguration clientConfiguration); AmazonWebServiceClient(ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector); @SdkProtectedApi protected AmazonWebServiceClient(ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector,
boolean disableStrictHostNameVerification); protected AmazonWebServiceClient(AwsSyncClientParams clientParams); @Deprecated void setEndpoint(String endpoint); Signer getSignerByURI(URI uri); @Deprecated void setRegion(Region region); @Deprecated final void configureRegion(Regions region); void shutdown(); @Deprecated void addRequestHandler(RequestHandler requestHandler); @Deprecated void addRequestHandler(RequestHandler2 requestHandler2); @Deprecated void removeRequestHandler(RequestHandler requestHandler); @Deprecated void removeRequestHandler(RequestHandler2 requestHandler2); void setTimeOffset(int timeOffset); AmazonWebServiceClient withTimeOffset(int timeOffset); int getTimeOffset(); RequestMetricCollector getRequestMetricsCollector(); String getServiceName(); String getEndpointPrefix(); final void setServiceNameIntern(String serviceName); final String getSignerRegionOverride(); final void setSignerRegionOverride(String signerRegionOverride); @Deprecated T withRegion(Region region); @Deprecated T withRegion(Regions region); @Deprecated T withEndpoint(String endpoint); @Deprecated @SdkInternalApi final void makeImmutable(); String getSignerOverride(); ClientConfiguration getClientConfiguration(); @Deprecated
static final boolean LOGGING_AWS_REQUEST_METRIC; } | @Test public void setServiceNameIntern() { AmazonTestClient client = new AmazonTestClient(); assertEquals(client.getServiceName(), client.getServiceNameIntern()); String serviceNameOverride = "foo"; assertFalse(serviceNameOverride.equals(client.getServiceName())); client.setServiceNameIntern(serviceNameOverride); assertEquals(serviceNameOverride, client.getServiceName()); } |
AmazonWebServiceClient { protected void setEndpointPrefix(String endpointPrefix) { if (endpointPrefix == null) { throw new IllegalArgumentException( "The parameter endpointPrefix must be specified!"); } this.endpointPrefix = endpointPrefix; } AmazonWebServiceClient(ClientConfiguration clientConfiguration); AmazonWebServiceClient(ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector); @SdkProtectedApi protected AmazonWebServiceClient(ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector,
boolean disableStrictHostNameVerification); protected AmazonWebServiceClient(AwsSyncClientParams clientParams); @Deprecated void setEndpoint(String endpoint); Signer getSignerByURI(URI uri); @Deprecated void setRegion(Region region); @Deprecated final void configureRegion(Regions region); void shutdown(); @Deprecated void addRequestHandler(RequestHandler requestHandler); @Deprecated void addRequestHandler(RequestHandler2 requestHandler2); @Deprecated void removeRequestHandler(RequestHandler requestHandler); @Deprecated void removeRequestHandler(RequestHandler2 requestHandler2); void setTimeOffset(int timeOffset); AmazonWebServiceClient withTimeOffset(int timeOffset); int getTimeOffset(); RequestMetricCollector getRequestMetricsCollector(); String getServiceName(); String getEndpointPrefix(); final void setServiceNameIntern(String serviceName); final String getSignerRegionOverride(); final void setSignerRegionOverride(String signerRegionOverride); @Deprecated T withRegion(Region region); @Deprecated T withRegion(Regions region); @Deprecated T withEndpoint(String endpoint); @Deprecated @SdkInternalApi final void makeImmutable(); String getSignerOverride(); ClientConfiguration getClientConfiguration(); @Deprecated
static final boolean LOGGING_AWS_REQUEST_METRIC; } | @Test public void setEndpointPrefix() { AmazonTestClient client = new AmazonTestClient(); Assert.assertEquals(client.getServiceName(), client.getEndpointPrefix()); String endpointPrefixOverride = "foo"; Assert.assertNotEquals(endpointPrefixOverride, client.getServiceName()); client.setEndpointPrefix(endpointPrefixOverride); Assert.assertEquals(endpointPrefixOverride, client.getEndpointPrefix()); Assert.assertNotEquals(client.getEndpointPrefix(), client.getServiceName()); } |
AmazonWebServiceClient { public void shutdown() { client.shutdown(); } AmazonWebServiceClient(ClientConfiguration clientConfiguration); AmazonWebServiceClient(ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector); @SdkProtectedApi protected AmazonWebServiceClient(ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector,
boolean disableStrictHostNameVerification); protected AmazonWebServiceClient(AwsSyncClientParams clientParams); @Deprecated void setEndpoint(String endpoint); Signer getSignerByURI(URI uri); @Deprecated void setRegion(Region region); @Deprecated final void configureRegion(Regions region); void shutdown(); @Deprecated void addRequestHandler(RequestHandler requestHandler); @Deprecated void addRequestHandler(RequestHandler2 requestHandler2); @Deprecated void removeRequestHandler(RequestHandler requestHandler); @Deprecated void removeRequestHandler(RequestHandler2 requestHandler2); void setTimeOffset(int timeOffset); AmazonWebServiceClient withTimeOffset(int timeOffset); int getTimeOffset(); RequestMetricCollector getRequestMetricsCollector(); String getServiceName(); String getEndpointPrefix(); final void setServiceNameIntern(String serviceName); final String getSignerRegionOverride(); final void setSignerRegionOverride(String signerRegionOverride); @Deprecated T withRegion(Region region); @Deprecated T withRegion(Regions region); @Deprecated T withEndpoint(String endpoint); @Deprecated @SdkInternalApi final void makeImmutable(); String getSignerOverride(); ClientConfiguration getClientConfiguration(); @Deprecated
static final boolean LOGGING_AWS_REQUEST_METRIC; } | @Test public void connectionManagersAreUnregisteredFromIdleConnectionReaper() { IdleConnectionReaper.shutdown(); for (int count = 0; count < 100; count++) { new AmazonWebServiceClient(new ClientConfiguration()) { }.shutdown(); } assertEquals(0, IdleConnectionReaper.getRegisteredConnectionManagers().size()); } |
DelegatingDnsResolver implements DnsResolver { @Override public InetAddress[] resolve(String host) throws UnknownHostException { return delegate.resolve(host); } DelegatingDnsResolver(com.ibm.cloud.objectstorage.DnsResolver delegate); @Override InetAddress[] resolve(String host); } | @Test public void testDelegatingDnsResolverCallsResolveOnDelegate() throws Exception { final AtomicInteger timesCalled = new AtomicInteger(); DnsResolver delegate = new DnsResolver() { @Override public InetAddress[] resolve(String host) throws UnknownHostException { timesCalled.incrementAndGet(); return new InetAddress[0]; } }; org.apache.http.conn.DnsResolver resolver = new DelegatingDnsResolver(delegate); resolver.resolve("localhost"); assertEquals("Delegate Resolver should have been executed", 1, timesCalled.get()); } |
CompleteMultipartUpload implements Callable<UploadResult> { @Override public UploadResult call() throws Exception { CompleteMultipartUploadResult res; try { CompleteMultipartUploadRequest req = new CompleteMultipartUploadRequest( origReq.getBucketName(), origReq.getKey(), uploadId, collectPartETags()) .withRequesterPays(origReq.isRequesterPays()) .withGeneralProgressListener(origReq.getGeneralProgressListener()) .withRequestMetricCollector(origReq.getRequestMetricCollector()) ; res = s3.completeMultipartUpload(req); } catch (Exception e) { monitor.uploadFailure(); publishProgress(listener, ProgressEventType.TRANSFER_FAILED_EVENT); throw e; } UploadResult uploadResult = new UploadResult(); uploadResult.setBucketName(origReq .getBucketName()); uploadResult.setKey(origReq.getKey()); uploadResult.setETag(res.getETag()); uploadResult.setVersionId(res.getVersionId()); monitor.uploadComplete(); return uploadResult; } CompleteMultipartUpload(String uploadId, AmazonS3 s3,
PutObjectRequest putObjectRequest, List<Future<PartETag>> futures,
List<PartETag> eTagsBeforeResume, ProgressListenerChain progressListenerChain,
UploadMonitor monitor); @Override UploadResult call(); } | @Test public void testReportFailureIsCalled() throws Exception{ UploadMonitor monitor = mock(UploadMonitor.class); CompleteMultipartUpload completeMultipartCopy = new CompleteMultipartUpload(null, null, null, null, null, null, monitor); try{ completeMultipartCopy.call(); } catch (Exception e){ } verify(monitor, times(1)).uploadFailure(); } |
CompleteMultipartCopy implements Callable<CopyResult> { @Override public CopyResult call() throws Exception { CompleteMultipartUploadResult res; try { CompleteMultipartUploadRequest req = new CompleteMultipartUploadRequest( origReq.getDestinationBucketName(), origReq.getDestinationKey(), uploadId, collectPartETags()) .withRequesterPays(origReq.isRequesterPays()) .withGeneralProgressListener(origReq.getGeneralProgressListener()) .withRequestMetricCollector(origReq.getRequestMetricCollector()) ; res = s3.completeMultipartUpload(req); } catch (Exception e) { monitor.reportFailure(); publishProgress(listener, ProgressEventType.TRANSFER_FAILED_EVENT); throw e; } CopyResult copyResult = new CopyResult(); copyResult.setSourceBucketName(origReq.getSourceBucketName()); copyResult.setSourceKey(origReq.getSourceKey()); copyResult.setDestinationBucketName(res .getBucketName()); copyResult.setDestinationKey(res.getKey()); copyResult.setETag(res.getETag()); copyResult.setVersionId(res.getVersionId()); monitor.copyComplete(); return copyResult; } CompleteMultipartCopy(String uploadId, AmazonS3 s3,
CopyObjectRequest copyObjectRequest, List<Future<PartETag>> futures,
ProgressListenerChain progressListenerChain, CopyMonitor monitor); @Override CopyResult call(); } | @Test public void testReportFailureIsCalled() throws Exception{ CopyMonitor monitor = mock(CopyMonitor.class); CompleteMultipartCopy completeMultipartCopy = new CompleteMultipartCopy(null, null, null, null, null, monitor); try{ completeMultipartCopy.call(); } catch (Exception e){ } verify(monitor, times(1)).reportFailure(); } |
RouteSimilarity { public RouteSimilarity(RouteData routeData, String currentRoute) { this.route = routeData.getNavigationTarget(); this.routeData = routeData; int urlSimilarity = calculateSimilarity(routeData.getUrl(), currentRoute); int routeAliasSimilarity = routeData.getRouteAliases().stream().map(routeAliasData -> calculateSimilarity(routeAliasData.getUrl(), currentRoute)).max(Integer::compareTo).orElse(0); similarity = Math.max(urlSimilarity, routeAliasSimilarity); } RouteSimilarity(RouteData routeData, String currentRoute); RouteSimilarity(String url, String currentRouteParts); RouteData getRouteData(); Class<? extends Component> getRoute(); String getRouteString(); int getSimilarity(); } | @Test public void testRouteSimilarity() { String[] urls = new String[]{ "navigation/view1", "navigation/view2", "navigation/view3", "navigation/view4", "navigation/view5", "navigation/view6", "navigation/view7", "navigation/view8", "navigation/view9", "navigation" }; String currentRoutePart = "navigation"; RouteSimilarity r = Arrays.stream(urls) .map(s -> new RouteSimilarity(currentRoutePart, s)) .max(Comparator.comparingInt(RouteSimilarity::getSimilarity)).get(); String result2 = urls[9]; Assert.assertEquals(r.getRouteString(), result2); } |
RouteSimilarity { public String getRouteString() { return routeString; } RouteSimilarity(RouteData routeData, String currentRoute); RouteSimilarity(String url, String currentRouteParts); RouteData getRouteData(); Class<? extends Component> getRoute(); String getRouteString(); int getSimilarity(); } | @Test public void testRouteSimilarity2() { String[] urls = new String[]{ "view1", "view2", "view3", "view4", "view5", "view6", "view7", "view8", "view9", "" }; String currentRoutePart = ""; RouteSimilarity r = Arrays.stream(urls) .map(s -> new RouteSimilarity(currentRoutePart, s)) .max(Comparator.comparingInt(RouteSimilarity::getSimilarity)).get(); String result1 = r.getRouteString(); String result2 = urls[9]; Assert.assertEquals(result1, result2); }
@Test public void testRouteSimilarity3() { String[] urls = new String[]{ "navigation/view2", "navigation2/view1", "navigation/view1", "navigation/view4", "navigation/view5", "navigation/view6", "navigation/view7", "navigation/view8", "navigation/view9", "navigation", }; String currentRoutePart = "navigation/view1"; RouteSimilarity r = Arrays.stream(urls) .map(s -> new RouteSimilarity(currentRoutePart, s)) .max(Comparator.comparingInt(RouteSimilarity::getSimilarity)).get(); String result1 = r.getRouteString(); String result2 = urls[2]; Assert.assertEquals(result1, result2); } |
UpNavigationHelper implements Serializable { public static Optional<RouteSimilarity> getClosestRoute(String url, String[] availableRoutes) { if (url.lastIndexOf("/") > 0) { Optional<RouteSimilarity> result = Arrays.stream(availableRoutes) .filter(routeData -> !routeData.equals(url)) .map(routeData -> new RouteSimilarity(routeData, url)) .max(Comparator.comparingInt(RouteSimilarity::getSimilarity)); if (result.isPresent()) { return result; } } return Optional.empty(); } private UpNavigationHelper(); static boolean routeHasUpNavigation(Class<? extends Component> navigationTarget); static UpNavigationHelper getUpNavigationHelper(); static void setUpNavigationHelper(); static Optional<RouteSimilarity> getClosestRoute(String url, String[] availableRoutes); static void performUpNavigation(Class<? extends Component> currentNavigation); static Optional<RouteData> getClosestRoute(String url); static boolean shouldHighlight(Class<? extends Component> className, Location location); static void registerNavigationRoute(Class<? extends Component> className); void register(Class<? extends Component> className); } | @Test public void getClosestRoute() { String[] urls = new String[]{ "navigation/view1", "navigation/view2", "navigation/view2/subview", "navigation/view3", "navigation/view4", "navigation/view5", "navigation/view6", "navigation/view7", "navigation/view8", "navigation/view9", "navigation" }; String currentRoutePart = "navigation/view2/subview"; RouteSimilarity res = UpNavigationHelper.getClosestRoute(currentRoutePart, urls).get(); String ress = res.getRouteString(); Assert.assertEquals(res.getRouteString(), "navigation/view2"); } |
EventDateComparator implements Comparator<EventAdapter.Item> { @Override public int compare(EventAdapter.Item event1, EventAdapter.Item event2) { if (event1.getEvent().getStart() == null) { if (event2.getEvent().getStart() == null) { return 0; } else { return 1; } } else if (event2.getEvent().getStart() == null) { return -1; } else { return event1.getEvent().getStart().compareTo(event2.getEvent().getStart()); } } @Override int compare(EventAdapter.Item event1, EventAdapter.Item event2); @Override boolean equals(Object obj); } | @Test public void valueAnEventHigherThanAnEventThatStartedBefore() { assertEquals(1, comparator.compare(eventInApril, eventInMarch)); assertEquals(-1, comparator.compare(eventInMarch, eventInApril)); assertEquals(0, comparator.compare(eventInMarch, eventInMarch)); }
@Test public void valueAnEventLowerThanAnEventWithoutStartDate() { assertEquals(-1, comparator.compare(eventInApril, eventWithoutStartDate)); assertEquals(1, comparator.compare(eventWithoutStartDate, eventInApril)); assertEquals(0, comparator.compare(eventWithoutStartDate, eventWithoutStartDate)); } |
LegacyAuthenticationHandlerAdapter implements AuthenticationHandler { @Override public HandlerResult authenticate(final Credential credential) throws GeneralSecurityException, PreventedException { try { if (this.legacyHandler.authenticate(credentialsAdapter.convert(credential))) { final CredentialMetaData md; if (credential instanceof CredentialMetaData) { md = (CredentialMetaData) credential; } else { md = new BasicCredentialMetaData(credential); } return new DefaultHandlerResult(this, md); } else { throw new FailedLoginException( String.format("%s failed to authenticate %s", this.getName(), credential)); } } catch (final org.jasig.cas.authentication.handler.AuthenticationException e) { throw new GeneralSecurityException( String.format("%s failed to authenticate %s", this.getName(), credential), e); } } LegacyAuthenticationHandlerAdapter(final org.jasig.cas.authentication.handler.AuthenticationHandler legacy); LegacyAuthenticationHandlerAdapter(
final org.jasig.cas.authentication.handler.AuthenticationHandler legacy,
final CredentialsAdapter adapter); @Override HandlerResult authenticate(final Credential credential); @Override boolean supports(final Credential credential); @Override String getName(); } | @Test public void verifyAuthenticateSuccess() throws Exception { final HandlerResult result = alwaysPassHandler.authenticate(new UsernamePasswordCredential("a", "b")); assertEquals("TestAlwaysPassAuthenticationHandler", result.getHandlerName()); }
@Test(expected = FailedLoginException.class) public void examineAuthenticateFailure() throws Exception { alwaysFailHandler.authenticate(new UsernamePasswordCredential("a", "b")); } |
LegacyAuthenticationHandlerAdapter implements AuthenticationHandler { @Override public boolean supports(final Credential credential) { return this.legacyHandler.supports(credentialsAdapter.convert(credential)); } LegacyAuthenticationHandlerAdapter(final org.jasig.cas.authentication.handler.AuthenticationHandler legacy); LegacyAuthenticationHandlerAdapter(
final org.jasig.cas.authentication.handler.AuthenticationHandler legacy,
final CredentialsAdapter adapter); @Override HandlerResult authenticate(final Credential credential); @Override boolean supports(final Credential credential); @Override String getName(); } | @Test public void verifySupports() throws Exception { assertTrue(alwaysPassHandler.supports(new UsernamePasswordCredential("a", "b"))); assertTrue(alwaysFailHandler.supports(new UsernamePasswordCredential("a", "b"))); }
@Test public void testSupports() throws Exception { assertTrue(alwaysPassHandler.supports(new UsernamePasswordCredential("a", "b"))); assertTrue(alwaysFailHandler.supports(new UsernamePasswordCredential("a", "b"))); } |
LegacyAuthenticationHandlerAdapter implements AuthenticationHandler { @Override public String getName() { if (this.legacyHandler instanceof NamedAuthenticationHandler) { return ((NamedAuthenticationHandler) this.legacyHandler).getName(); } else { return this.legacyHandler.getClass().getSimpleName(); } } LegacyAuthenticationHandlerAdapter(final org.jasig.cas.authentication.handler.AuthenticationHandler legacy); LegacyAuthenticationHandlerAdapter(
final org.jasig.cas.authentication.handler.AuthenticationHandler legacy,
final CredentialsAdapter adapter); @Override HandlerResult authenticate(final Credential credential); @Override boolean supports(final Credential credential); @Override String getName(); } | @Test public void verifyGetName() throws Exception { assertEquals("TestAlwaysPassAuthenticationHandler", alwaysPassHandler.getName()); assertEquals("TestAlwaysFailAuthenticationHandler", alwaysFailHandler.getName()); }
@Test public void testGetName() throws Exception { assertEquals("TestAlwaysPassAuthenticationHandler", alwaysPassHandler.getName()); assertEquals("TestAlwaysFailAuthenticationHandler", alwaysFailHandler.getName()); } |
SmartOpenIdController extends DelegateController implements Serializable { @Override public boolean canHandle(final HttpServletRequest request, final HttpServletResponse response) { final String openIdMode = request.getParameter(OpenIdConstants.OPENID_MODE); if (StringUtils.equals(openIdMode, OpenIdConstants.ASSOCIATE)) { logger.info("Handling request. openid.mode : {}", openIdMode); return true; } logger.info("Cannot handle request. openid.mode : {}", openIdMode); return false; } Map<String, String> getAssociationResponse(final HttpServletRequest request); @Override boolean canHandle(final HttpServletRequest request, final HttpServletResponse response); void setSuccessView(final String successView); void setFailureView(final String failureView); @NotNull void setServerManager(final ServerManager serverManager); } | @Test public void verifyCanHandle() { request.addParameter("openid.mode", "associate"); final boolean canHandle = smartOpenIdController.canHandle(request, response); request.removeParameter("openid.mode"); assertEquals(true, canHandle); }
@Test public void verifyCannotHandle() { request.addParameter("openid.mode", "anythingElse"); final boolean canHandle = smartOpenIdController.canHandle(request, response); request.removeParameter("openid.mode"); assertEquals(false, canHandle); } |
SmartOpenIdController extends DelegateController implements Serializable { public Map<String, String> getAssociationResponse(final HttpServletRequest request) { final ParameterList parameters = new ParameterList(request.getParameterMap()); final String mode = parameters.hasParameter(OpenIdConstants.OPENID_MODE) ? parameters.getParameterValue(OpenIdConstants.OPENID_MODE) : null; Message response = null; if (StringUtils.equals(mode, OpenIdConstants.ASSOCIATE)) { response = serverManager.associationResponse(parameters); } final Map<String, String> responseParams = new HashMap<>(); if (response != null) { responseParams.putAll(response.getParameterMap()); } return responseParams; } Map<String, String> getAssociationResponse(final HttpServletRequest request); @Override boolean canHandle(final HttpServletRequest request, final HttpServletResponse response); void setSuccessView(final String successView); void setFailureView(final String failureView); @NotNull void setServerManager(final ServerManager serverManager); } | @Test public void verifyGetAssociationResponse() { request.addParameter("openid.mode", "associate"); request.addParameter("openid.session_type", "DH-SHA1"); request.addParameter("openid.assoc_type", "HMAC-SHA1"); request.addParameter("openid.dh_consumer_public", "NzKoFMyrzFn/5iJFPdX6MVvNA/BChV1/sJdnYbupDn7ptn+cerwEzyFfWFx25KsoLSkxQCaSMmYtc1GPy/2GI1BSKSDhpdJmDBb" + "QRa/9Gs+giV/5fHcz/mHz8sREc7RTGI+0Ka9230arwrWt0fnoaJLRKEGUsmFR71rCo4EUOew="); final Map<String, String> assocResponse = smartOpenIdController.getAssociationResponse(request); assertTrue(assocResponse.containsKey("assoc_handle")); assertTrue(assocResponse.containsKey("expires_in")); assertTrue(assocResponse.containsKey("dh_server_public")); assertTrue(assocResponse.containsKey("enc_mac_key")); request.removeParameter("openid.mode"); } |
CompositionBundle implements Bundle { private static Function composition(Context context) { return args -> { final Composition composition; switch (args.length) { case 0: composition = new Composition(); break; case 1: double frameRate = args[0].asDouble(); composition = new Composition(frameRate); break; case 2: int width = args[0].asInt(); int height = args[1].asInt(); composition = new Composition(width, height); break; case 3: width = args[0].asInt(); height = args[1].asInt(); frameRate = args[2].asDouble(); composition = new Composition(width, height, frameRate); break; case 4: default: width = args[0].asInt(); height = args[1].asInt(); frameRate = args[2].asDouble(); final var background = PropertyType.PAINT.<Paint>getFromHFX().apply(args[3]); composition = new Composition(width, height, frameRate, background); break; } final var scene = composition.getScene(); context.composition(composition); context.variables().put("Width", NumberValue.of(scene.getVirtualWidth())); context.variables().put("Height", NumberValue.of(scene.getVirtualHeight())); context.variables().put("HalfWidth", NumberValue.of(scene.getVirtualWidth() / 2)); context.variables().put("HalfHeight", NumberValue.of(scene.getVirtualHeight() / 2)); return NumberValue.ZERO; }; } @Override Map<String, FunctionInfo> functionsInfo(); } | @Test void testBundle() { final var context = new Context(); BundleLoader.loadSingle(context, CompositionBundle.class); assertThat(context.functions(), hasKey("composition")); assertThat(context.composition(), nullValue()); assertThat(context.variables(), allOf( not(hasKey("Width")), not(hasKey("Height")), not(hasKey("HalfWidth")), not(hasKey("HalfHeight")) )); context.functions().get("composition").execute(); assertThat(context.composition(), notNullValue()); assertThat(context.variables(), allOf( hasEntry("Width", NumberValue.of(1920)), hasEntry("Height", NumberValue.of(1080)), hasEntry("HalfWidth", NumberValue.of(960)), hasEntry("HalfHeight", NumberValue.of(540)) )); } |
HotaruLexer extends Lexer { private Token tokenizeText(char openChar) { next(); clearBuffer(); int startPos = getPos() - 1; char current = peek(0); while (true) { if (current == '\\') { final var buffer = getBuffer(); current = next(); if (current == openChar) { current = next(); buffer.append(openChar); continue; } switch (current) { case '0': current = next(); buffer.append('\0'); continue; case 'b': current = next(); buffer.append('\b'); continue; case 'f': current = next(); buffer.append('\f'); continue; case 'n': current = next(); buffer.append('\n'); continue; case 'r': current = next(); buffer.append('\r'); continue; case 't': current = next(); buffer.append('\t'); continue; case 'u': int rollbackPosition = getPos(); while (current == 'u') { current = next(); } int escapedValue = 0; for (int i = 12; i >= 0 && escapedValue != -1; i -= 4) { if (isHexNumber(current)) { escapedValue |= (Character.digit(current, 16) << i); } else { escapedValue = -1; } current = next(); } if (escapedValue >= 0) { buffer.append((char) escapedValue); } else { buffer.append("\\u"); setPos(rollbackPosition); } continue; } buffer.append('\\'); continue; } if (current == openChar) break; if (current == '\0') { throw error("Reached end of file while parsing text"); } getBuffer().append(current); current = next(); } next(); int actualLength = getPos() - startPos; return addToken(HotaruTokenId.TEXT, getBuffer().toString(), actualLength); } HotaruLexer(String input); static List<Token> tokenize(String input); Token nextToken(); } | @Test void testTokenizeText() { assertThat(t("1 \" 1\n2 3 '\""), contains( tokenId(HotaruTokenId.NUMBER), tokenId(HotaruTokenId.TEXT) )); assertThat(t("1 ' 1\n2 3 ' 2"), contains( tokenId(HotaruTokenId.NUMBER), tokenId(HotaruTokenId.TEXT), tokenId(HotaruTokenId.NUMBER) )); assertThrows(LexerException.class, () -> { all("' ... "); }); assertThat(single("'\\\''").getText(), is("'")); assertThat(single("\'\\\"\'").getText(), is("\\\"")); assertThat(single("\"\\\"\"").getText(), is("\"")); assertThat(single("\"\\\'\"").getText(), is("\\\'")); } |
InterpreterVisitor implements ResultVisitor<Value, Context> { @Override public Value get(AccessNode node, Context context) { Value container = node.root.accept(this, context); return getContainer(node.indices, context, container) .orElseThrow(() -> new TypeException("Unable to get property from non-accessible type", node.start(), node.end())); } @Override Value visit(AccessNode node, Context context); @Override Value visit(ArrayNode node, Context context); @Override Value visit(AssignNode node, Context context); @Override Value visit(BlockNode node, Context context); @Override Value visit(FunctionNode node, Context context); @Override Value visit(MapNode node, Context context); @Override Value visit(PropertyNode node, Context context); @Override Value visit(UnaryNode node, Context context); @Override Value visit(UnitNode node, Context context); @Override Value visit(ValueNode node, Context context); @Override Value visit(VariableNode node, Context context); @Override Value get(AccessNode node, Context context); @Override Value set(AccessNode node, Value value, Context context); @Override Value get(VariableNode node, Context context); @Override Value set(VariableNode node, Value value, Context context); } | @Test void testMapAccess() { Context context = new Context(); eval("A = {x: 0, y: 22, z: 0, text: 'hello'}\n" + "A.x = 20\n" + "A.z = A.y\n" + "A.newKey = 'newValue'", context); Value value = context.variables().get("A"); assertThat(value, instanceOf(MapValue.class)); Map<String, Value> map = ((MapValue) value).getMap(); assertThat(map, allOf( hasEntry("x", NumberValue.of(20)), hasEntry("y", NumberValue.of(22)), hasEntry("z", NumberValue.of(22)) )); assertThat(map, allOf( hasEntry("text", new StringValue("hello")), hasEntry("newKey", new StringValue("newValue")) )); }
@Test void testUnits() { final var context = new Context(); BundleLoader.loadSingle(context, CompositionBundle.class); context.functions().put("rate", context.functions().get("composition")); Value value; value = eval("rate(30) t = 1 sec", context); assertThat(value.asDouble(), closeTo(30, 0.0001)); value = eval("rate(30) t = 5 sec", context); assertThat(value.asDouble(), closeTo(150, 0.0001)); value = eval("rate(30) t = 0.5 sec", context); assertThat(value.asDouble(), closeTo(15, 0.0001)); value = eval("rate(30) t = 1000 ms", context); assertThat(value.asDouble(), closeTo(30, 0.0001)); value = eval("rate(30) t = 333 ms", context); assertThat(value.asDouble(), closeTo(10, 0.01)); value = eval("rate(25) t = 1 sec", context); assertThat(value.asDouble(), closeTo(25, 0.0001)); value = eval("rate(25) t = 1000 ms", context); assertThat(value.asDouble(), closeTo(25, 0.0001)); } |
Composition { public int getVirtualWidth() { return virtualWidth; } Composition(); Composition(double frameRate); Composition(int sceneWidth, int sceneHeight); Composition(int sceneWidth, int sceneHeight, double frameRate); Composition(int sceneWidth, int sceneHeight, double frameRate, Paint background); int getVirtualWidth(); int getVirtualHeight(); int getSceneWidth(); int getSceneHeight(); double getFactor(); TimeLine getTimeline(); VirtualScene getScene(); Paint getBackground(); Scene producePreviewScene(); Scene produceRendererScene(); } | @Test void testVirtualSize() { Composition composition; composition = new Composition(1280, 720, 30); assertThat(composition.getVirtualWidth(), is(1920)); composition = new Composition(1280, 1280, 30); assertThat(composition.getVirtualWidth(), is(1080)); } |
CGLibProxy implements MethodInterceptor { public <T> T proxy(Class<T> clazz, Object shadowObject) { if (!ArgumentsUtils.hasNoArgumentsConstructor(clazz)) { Class[] argTypes = ArgumentsUtils.getConstructorsArgumensTypes(clazz); Object[] args = ArgumentsUtils.getArgumens(argTypes); return proxy(clazz, shadowObject, argTypes, args); } this.shadowObject = shadowObject; Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(clazz); enhancer.setCallback(this); T proxy = (T) enhancer.create(); if (shadowObject instanceof Shadow) { ((Shadow) shadowObject).setProxyObject(proxy); } return proxy; } T proxy(Class<T> clazz, Object shadowObject); T proxy(Class<T> clazz, Object shadowObject, Class[] argTypes, Object[] args); @Override Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy); } | @Test public void getInstance() throws Exception { A proxyA = new CGLibProxy().proxy(A.class, new B()); Assert.assertTrue(proxyA instanceof A); } |
KbSqlParser { public static String bindArgs(String sql, @Nullable Object[] bindArgs) { if (bindArgs == null || bindArgs.length == 0 || sql.startsWith("PRAGMA")) { return sql; } try { KbSqlParserManager pm = new KbSqlParserManager(); Statement statement = pm.parse(sql); Set<Expression> expressionSet = findBindArgsExpressions(statement); Iterator<Object> iterator = Arrays.asList(bindArgs).iterator(); bindExpressionArgs(expressionSet, iterator); return statement.toString(); } catch (Exception e) { e.printStackTrace(); } return sql; } static String bindArgs(String sql, @Nullable Object[] bindArgs); } | @Test public void bindDeleteArgs() { Object[] args = new Object[]{1}; String sql = "DELETE FROM person WHERE id = ?"; String boundSql = KbSqlParser.bindArgs(sql, args); Assert.assertEquals("DELETE FROM person WHERE id = 1", boundSql); }
@Test public void bindUpdateArgs() { Object[] args = new Object[]{"kk", 1}; String sql = "UPDATE person SET name = ? WHERE id = ?"; String boundSql = KbSqlParser.bindArgs(sql, args); Assert.assertEquals("UPDATE person SET name = 'kk' WHERE id = 1", boundSql); }
@Test public void bindSelectArgs() throws Exception { Object[] args = new Object[]{1, 10, 20, "test"}; String sql = "select * from person where id=? and (uid BETWEEN ? and ?) and test LIKE ? order by id"; String boundSql = KbSqlParser.bindArgs(sql, args); System.out.println(boundSql); Assert.assertEquals("SELECT * FROM person WHERE id = 1 AND (uid BETWEEN 10 AND 20) AND test LIKE 'test' ORDER BY id", boundSql); }
@Test public void bindInsertArgs() { Object[] args = new Object[]{1, "kk"}; String sql = "INSERT INTO person (id, name) VALUES (?, ?)"; String boundSql = KbSqlParser.bindArgs(sql, args); Assert.assertEquals("INSERT INTO person (id, name) VALUES (1, 'kk')", boundSql); } |
KbSqlParser { protected static int getBindArgsCount(String sql) { Set<Expression> expressionSet = findBindArgsExpressions(sql); int count = 0; for (Expression expression : expressionSet) { count += getBindArgsCount(expression); } return count; } static String bindArgs(String sql, @Nullable Object[] bindArgs); } | @Test public void getBindArgsCount() throws Exception { String sql0 = "select * from person where id=? and (uid BETWEEN ? and ?) and test LIKE ? order by id"; String sql1 = "INSERT INTO person (id, name) VALUES (?, ?)"; String sql2 = "DELETE FROM person WHERE id in (?,?)"; String sql3 = "UPDATE person SET name = ? WHERE id = ?"; Assert.assertEquals(4, KbSqlParser.getBindArgsCount(sql0)); Assert.assertEquals(2, KbSqlParser.getBindArgsCount(sql1)); Assert.assertEquals(2, KbSqlParser.getBindArgsCount(sql2)); Assert.assertEquals(2, KbSqlParser.getBindArgsCount(sql3)); } |
KbSqlParser { protected static Set<Expression> findBindArgsExpressions(String sql) { if (sql == null || sql.startsWith("PRAGMA") || !sql.contains("?")) { return new LinkedHashSet<>(); } KbSqlParserManager pm = new KbSqlParserManager(); try { Statement statement = pm.parse(sql); Set<Expression> expressionSet = findBindArgsExpressions(statement); return expressionSet; } catch (JSQLParserException e) { e.printStackTrace(); } return new LinkedHashSet<>(); } static String bindArgs(String sql, @Nullable Object[] bindArgs); } | @Test public void findJdbcParamExpressions() throws Exception { String sql = "DELETE FROM person WHERE id = ?"; Set<Expression> expressionSet = KbSqlParser.findBindArgsExpressions(sql); System.out.println(); } |
ShadowContext implements Shadow { public File getFilesDir() { return getAndCreateDir("build/files/"); } ShadowContext(Resources resources); ShadowContext(Resources resources, ShadowResources shadowResources); @NonNull final String getString(@StringRes int resId); Resources getResources(); SharedPreferences getSharedPreferences(String name, int mode); Context getApplicationContext(); File getDatabasePath(String name); AssetManager getAssets(); String getPackageName(); File getFilesDir(); File getCacheDir(); File getDataDir(); void putSQLiteDatabase(String name, SQLiteDatabase db); SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory); @TargetApi(Build.VERSION_CODES.JELLY_BEAN) SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler); boolean deleteDatabase(String name); Map<String, SQLiteDatabase> getDbMap(); @Override String toString(); @Override void setProxyObject(Object proxyObject); void setApplication(Application application); } | @Test public void getFilesDir() throws Exception { List<File> dirs = Arrays.asList(mShadowContext.getFilesDir(), mShadowContext.getCacheDir(), mShadowContext.getDataDir()); for (File dir : dirs) { Assert.assertTrue(dir.isDirectory()); Assert.assertTrue(dir.exists()); } } |
ShadowResources { public String getString(@StringRes int id) throws NotFoundException { return getText(id).toString(); } ShadowResources(); int getColor(@ColorRes int id); int getColor(@ColorRes int id, @Nullable Resources.Theme theme); String getString(@StringRes int id); @NonNull String[] getStringArray(@ArrayRes int id); @NonNull int[] getIntArray(@ArrayRes int id); String getPackageName(); } | @Test public void getString() throws Exception { Assert.assertEquals("Yui Hatano", resources.getString(R.string.test_string)); } |
ShadowResources { @NonNull public String[] getStringArray(@ArrayRes int id) throws NotFoundException { Map<Integer, String> idNameMap = getIdTable(R_ARRAY); Map<String, List<String>> stringArrayMap = getResourceStringArrayMap(); if (idNameMap.containsKey(id)) { String name = idNameMap.get(id); if (stringArrayMap.containsKey(name)) { List<String> stringList = stringArrayMap.get(name); return stringList.toArray(new String[0]); } } throw new Resources.NotFoundException("String array resource ID #0x" + Integer.toHexString(id)); } ShadowResources(); int getColor(@ColorRes int id); int getColor(@ColorRes int id, @Nullable Resources.Theme theme); String getString(@StringRes int id); @NonNull String[] getStringArray(@ArrayRes int id); @NonNull int[] getIntArray(@ArrayRes int id); String getPackageName(); } | @Test public void getStringArray() throws Exception { String[] array = resources.getStringArray(R.array.arrayName); Assert.assertEquals("item0", array[0]); Assert.assertEquals("item1", array[1]); } |
ShadowResources { public int getColor(@ColorRes int id) throws NotFoundException { return getColor(id, null); } ShadowResources(); int getColor(@ColorRes int id); int getColor(@ColorRes int id, @Nullable Resources.Theme theme); String getString(@StringRes int id); @NonNull String[] getStringArray(@ArrayRes int id); @NonNull int[] getIntArray(@ArrayRes int id); String getPackageName(); } | @Test public void getColor() throws Exception { int color = resources.getColor(R.color.my_color); int realColor = Color.parseColor("#47474d"); Assert.assertEquals(realColor, color); } |
ShadowResources { @NonNull public int[] getIntArray(@ArrayRes int id) throws NotFoundException { Map<Integer, String> idNameMap = getIdTable(R_ARRAY); Map<String, List<Integer>> intArrayMap = getResourceIntArrayMap(); if (idNameMap.containsKey(id)) { String name = idNameMap.get(id); if (intArrayMap.containsKey(name)) { List<Integer> intList = intArrayMap.get(name); int[] intArray = new int[intList.size()]; for (int i = 0; i < intList.size(); i++) { intArray[i] = intList.get(i); } return intArray; } } return new int[0]; } ShadowResources(); int getColor(@ColorRes int id); int getColor(@ColorRes int id, @Nullable Resources.Theme theme); String getString(@StringRes int id); @NonNull String[] getStringArray(@ArrayRes int id); @NonNull int[] getIntArray(@ArrayRes int id); String getPackageName(); } | @Test public void getIntArray() { int[] intArray = resources.getIntArray(R.array.intArray); Assert.assertEquals(0, intArray[0]); Assert.assertEquals(1, intArray[1]); int[] intArrayNoItem = resources.getIntArray(R.array.intArrayNoItem); Assert.assertEquals(0, intArrayNoItem.length); } |
ShadowResources { public String getPackageName() { if (!TextUtils.isEmpty(mPackageName)) { return mPackageName; } String manifestPath = null; List<String> manifestPaths = Arrays.asList( "build/intermediates/manifests/aapt/debug/AndroidManifest.xml", "build/intermediates/manifests/aapt/release/AndroidManifest.xml", "build/intermediates/manifests/aapt/full/release/AndroidManifest.xml", "build/intermediates/manifests/full/debug/AndroidManifest.xml", "build/intermediates/aapt_friendly_merged_manifests/debug/processDebugManifest/aapt/AndroidManifest.xml", "build/intermediates/aapt_friendly_merged_manifests/release/processDebugManifest/aapt/AndroidManifest.xml", "build/intermediates/merged_manifests/debug/processDebugManifest/merged/AndroidManifest.xml", "build/intermediates/merged_manifests/release/processDebugManifest/merged/AndroidManifest.xml", "build/intermediates/merged_manifests/debug/AndroidManifest.xml", "build/intermediates/library_manifest/debug/AndroidManifest.xml", "build/intermediates/aapt_friendly_merged_manifests/debug/processDebugManifest/aapt/AndroidManifest.xml" ); manifestPath = findExistPath(manifestPaths); if (TextUtils.isEmpty(manifestPath)) { manifestPath = findPath("AndroidManifest.xml", "build/intermediates"); } if (TextUtils.isEmpty(manifestPath)) { throw new RuntimeException("没有找到AndroidManifest.xml"); } FileReader reader = new FileReader(); if (new File(manifestPath).exists()) { String manifest = reader.readString(manifestPath); Element body = Jsoup.parse(manifest).body(); String packageName = body.childNode(0).attr("package"); return mPackageName = packageName; } else { manifestPath = "build/intermediates/manifest/androidTest/debug/AndroidManifest.xml"; String manifest = reader.readString(manifestPath); Element body = Jsoup.parse(manifest).body(); String packageName = body.childNode(0).attr("package"); packageName = packageName.substring(0, packageName.length() - ".test".length()); return mPackageName = packageName; } } ShadowResources(); int getColor(@ColorRes int id); int getColor(@ColorRes int id, @Nullable Resources.Theme theme); String getString(@StringRes int id); @NonNull String[] getStringArray(@ArrayRes int id); @NonNull int[] getIntArray(@ArrayRes int id); String getPackageName(); } | @Test public void getPackageName() throws Exception { Assert.assertEquals("net.yui", resources.getPackageName()); } |
ReflectUtils { public static Object invokeStatic(String className, String methodName, Object... arguments) { try { Class clazz = Class.forName(className); return invokeStatic(clazz, methodName, arguments); } catch (ClassNotFoundException e) { e.printStackTrace(); } return null; } static boolean hasClass(String className); static void setField(Object receiver, String fieldName, Object value); static Object invoke(Object receiver, String methodName, Object... arguments); static Object invokeStatic(String className, String methodName, Object... arguments); static Object invokeStatic(Class clazz, String methodName, Object... arguments); static Object newObject(String className, Object... args); static Method findMethod(Class clazz, String methodName, Class... argumentTypes); } | @Test public void invokeStatic() { Assert.assertEquals("value", ReflectUtils.invokeStatic("net.yui.utils.MockHelper", "testStatic")); Assert.assertEquals("arg0", ReflectUtils.invokeStatic("net.yui.utils.MockHelper", "testStatic", "arg0")); MockHelper mockHelper = new MockHelper(); Assert.assertEquals("value", ReflectUtils.invoke(mockHelper, "testMethod")); Assert.assertEquals("arg0", ReflectUtils.invoke(mockHelper, "testMethod", "arg0")); } |
FileUtils { public static boolean deleteDir(File dir) { if (dir.isDirectory()) { String[] children = dir.list(); for (int i = 0; i < children.length; i++) { boolean success = deleteDir(new File(dir, children[i])); if (!success) { return false; } } } return dir.delete(); } static boolean deleteDir(File dir); } | @Test public void deleteDir() throws Exception { File dir = new File("build/files"); dir.mkdirs(); File file = new File(dir, "myfile"); file.createNewFile(); Assert.assertTrue(file.exists()); Assert.assertFalse(dir.delete()); Assert.assertTrue(dir.exists()); FileUtils.deleteDir(dir); Assert.assertFalse(dir.exists()); } |
ArgumentsUtils { public static Class[] getConstructorsArgumensTypes(Class clazz) { Constructor[] constructors = getNotPrivateConstructors(clazz); if (constructors == null || constructors.length == 0) { return new Class[0]; } return constructors[0].getParameterTypes(); } static Class[] getConstructorsArgumensTypes(Class clazz); static boolean hasNoArgumentsConstructor(Class clazz); static Object[] getArgumens(Class[] argTypes); } | @Test public void getConstructorsArgumensTypes() { ArgumentsUtils.getConstructorsArgumensTypes(Object.class); } |
ShadowCursor implements Cursor { protected Object getObject(int columnIndex, Object defaultValue) { Object value = getObject(columnIndex); if (value == null) { return defaultValue; } return value; } ShadowCursor(List<String> colums, List<List<Object>> datas); @Override int getCount(); @Override int getPosition(); @Override boolean move(int offset); @Override boolean moveToPosition(int position); @Override boolean moveToFirst(); @Override boolean moveToLast(); @Override boolean moveToNext(); @Override boolean moveToPrevious(); @Override boolean isFirst(); @Override boolean isLast(); @Override boolean isBeforeFirst(); @Override boolean isAfterLast(); @Override int getColumnIndex(String columnName); @Override int getColumnIndexOrThrow(String columnName); @Override String getColumnName(int columnIndex); @Override String[] getColumnNames(); @Override int getColumnCount(); @Override byte[] getBlob(int columnIndex); @Override String getString(int columnIndex); @Override void copyStringToBuffer(int columnIndex, CharArrayBuffer buffer); @Override short getShort(int columnIndex); @Override int getInt(int columnIndex); @Override long getLong(int columnIndex); @Override float getFloat(int columnIndex); @Override double getDouble(int columnIndex); @Override int getType(int columnIndex); @Override boolean isNull(int columnIndex); @Override void deactivate(); @Override boolean requery(); @Override void close(); @Override boolean isClosed(); @Override void registerContentObserver(ContentObserver observer); @Override void unregisterContentObserver(ContentObserver observer); @Override void registerDataSetObserver(DataSetObserver observer); @Override void unregisterDataSetObserver(DataSetObserver observer); @Override void setNotificationUri(ContentResolver cr, Uri uri); @Override Uri getNotificationUri(); @Override boolean getWantsAllOnMoveCalls(); @Override void setExtras(Bundle extras); @Override Bundle getExtras(); @Override Bundle respond(Bundle extras); } | @Test public void getObject() { List<Object> data0 = Arrays.asList((Object) 1, "kk"); cursor = new ShadowCursor(Arrays.asList("id", "name"), Arrays.asList(data0)); cursor.moveToFirst(); Assert.assertEquals(1, cursor.getObject(0)); Assert.assertEquals("kk", cursor.getObject(1)); } |
ShadowCursor implements Cursor { @Override public String getString(int columnIndex) { Object value = getObject(columnIndex); return value == null ? null : value.toString(); } ShadowCursor(List<String> colums, List<List<Object>> datas); @Override int getCount(); @Override int getPosition(); @Override boolean move(int offset); @Override boolean moveToPosition(int position); @Override boolean moveToFirst(); @Override boolean moveToLast(); @Override boolean moveToNext(); @Override boolean moveToPrevious(); @Override boolean isFirst(); @Override boolean isLast(); @Override boolean isBeforeFirst(); @Override boolean isAfterLast(); @Override int getColumnIndex(String columnName); @Override int getColumnIndexOrThrow(String columnName); @Override String getColumnName(int columnIndex); @Override String[] getColumnNames(); @Override int getColumnCount(); @Override byte[] getBlob(int columnIndex); @Override String getString(int columnIndex); @Override void copyStringToBuffer(int columnIndex, CharArrayBuffer buffer); @Override short getShort(int columnIndex); @Override int getInt(int columnIndex); @Override long getLong(int columnIndex); @Override float getFloat(int columnIndex); @Override double getDouble(int columnIndex); @Override int getType(int columnIndex); @Override boolean isNull(int columnIndex); @Override void deactivate(); @Override boolean requery(); @Override void close(); @Override boolean isClosed(); @Override void registerContentObserver(ContentObserver observer); @Override void unregisterContentObserver(ContentObserver observer); @Override void registerDataSetObserver(DataSetObserver observer); @Override void unregisterDataSetObserver(DataSetObserver observer); @Override void setNotificationUri(ContentResolver cr, Uri uri); @Override Uri getNotificationUri(); @Override boolean getWantsAllOnMoveCalls(); @Override void setExtras(Bundle extras); @Override Bundle getExtras(); @Override Bundle respond(Bundle extras); } | @Test public void getString() { List<Object> data0 = Arrays.asList((Object) 1, "kk"); List<Object> data1 = Arrays.asList((Object) 2, null); cursor = new ShadowCursor(Arrays.asList("id", "name"), Arrays.asList(data0, data1)); cursor.moveToFirst(); Assert.assertEquals("1", cursor.getString(0)); Assert.assertEquals("kk", cursor.getString(1)); cursor.moveToNext(); Assert.assertEquals("2", cursor.getString(0)); Assert.assertEquals(null, cursor.getString(1)); } |
XMLUtils { public static Document stringToDoc(String str) throws IOException { if (StringUtils.isNotEmpty(str)) { try { Reader reader = new StringReader(str); DocumentBuilder db = DocumentBuilderFactory.newInstance() .newDocumentBuilder(); Document doc = db.parse(new InputSource(reader)); reader.close(); return doc; } catch (Exception ex) { log.debug("String: {}", str); throw new IOException(String.format("Error converting from string to doc %s", ex.getMessage())); } } else { throw new IOException("Error - could not convert empty string to doc"); } } static Document stringToDoc(String str); static String docToString(Document dom); static String docToString1(Document dom); static String docToString2(Document domDoc); } | @Test public void testStringToDoc() throws IOException { XMLUtils.stringToDoc(XML_STRING); XMLUtils.stringToDoc(XML_STRING_HUGE); } |
JMXFactory { public String getDomain() { return domain; } static ObjectName createMBean(String className, String attributes); static ObjectName createObjectName(String... strings); static ObjectName createSimpleMBean(String className,
String objectNameStr); static String getDefaultDomain(); static MBeanServer getMBeanServer(); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass, ObjectName name); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass, String name); String getDomain(); void setDomain(String domain); } | @Test public void testGetDomain() { System.out.println("Not yet implemented"); } |
JMXFactory { public static MBeanServer getMBeanServer() { return mbs; } static ObjectName createMBean(String className, String attributes); static ObjectName createObjectName(String... strings); static ObjectName createSimpleMBean(String className,
String objectNameStr); static String getDefaultDomain(); static MBeanServer getMBeanServer(); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass, ObjectName name); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass, String name); String getDomain(); void setDomain(String domain); } | @Test public void testGetMBeanServer() { System.out.println("Not yet implemented"); } |
JMXFactory { public void setDomain(String domain) { JMXFactory.domain = domain; } static ObjectName createMBean(String className, String attributes); static ObjectName createObjectName(String... strings); static ObjectName createSimpleMBean(String className,
String objectNameStr); static String getDefaultDomain(); static MBeanServer getMBeanServer(); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass, ObjectName name); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass, String name); String getDomain(); void setDomain(String domain); } | @Test public void testSetDomain() { System.out.println("Not yet implemented"); } |
ClientRegistry implements IClientRegistry, ClientRegistryMBean { public IClient newClient(Object[] params) throws ClientNotFoundException, ClientRejectedException { String id = nextId(); IClient client = new Client(id, this); addClient(id, client); return client; } ClientRegistry(); ClientRegistry(String name); Client getClient(String id); ClientList<Client> getClientList(); boolean hasClient(String id); IClient lookupClient(String id); IClient newClient(Object[] params); String nextId(); String previousId(); } | @Test public void testNewClient() { IClient client = reg.newClient(null); Assert.assertNotNull(client); Assert.assertTrue(client.getId() != null); Assert.assertTrue(Integer.valueOf(client.getId()) >= 0); } |
ClientRegistry implements IClientRegistry, ClientRegistryMBean { protected void addClient(IClient client) { addClient(client.getId(), client); } ClientRegistry(); ClientRegistry(String name); Client getClient(String id); ClientList<Client> getClientList(); boolean hasClient(String id); IClient lookupClient(String id); IClient newClient(Object[] params); String nextId(); String previousId(); } | @Test public void testAddClient() { reg.addClient(new Client(reg.nextId(), reg)); Assert.assertNotNull(reg.getClient("1")); Assert.assertTrue(reg.getClients().size() >= 1); } |
ClientRegistry implements IClientRegistry, ClientRegistryMBean { public IClient lookupClient(String id) throws ClientNotFoundException { return getClient(id); } ClientRegistry(); ClientRegistry(String name); Client getClient(String id); ClientList<Client> getClientList(); boolean hasClient(String id); IClient lookupClient(String id); IClient newClient(Object[] params); String nextId(); String previousId(); } | @Test public void testLookupClient() { IClient client = reg.lookupClient("0"); Assert.assertNotNull(client); } |
ClientRegistry implements IClientRegistry, ClientRegistryMBean { public Client getClient(String id) throws ClientNotFoundException { final Client result = (Client) clients.get(id); if (result == null) { throw new ClientNotFoundException(id); } return result; } ClientRegistry(); ClientRegistry(String name); Client getClient(String id); ClientList<Client> getClientList(); boolean hasClient(String id); IClient lookupClient(String id); IClient newClient(Object[] params); String nextId(); String previousId(); } | @Test public void testGetClient() { IClient client = reg.getClient("0"); Assert.assertNotNull(client); IClient client2 = null; try { client2 = reg.getClient("999999"); fail("An exception should occur here"); } catch (ClientNotFoundException e) { Assert.assertTrue(true); } Assert.assertNull(client2); } |
ClientRegistry implements IClientRegistry, ClientRegistryMBean { public ClientList<Client> getClientList() { ClientList<Client> list = new ClientList<Client>(); for (IClient c : clients.values()) { list.add((Client) c); } return list; } ClientRegistry(); ClientRegistry(String name); Client getClient(String id); ClientList<Client> getClientList(); boolean hasClient(String id); IClient lookupClient(String id); IClient newClient(Object[] params); String nextId(); String previousId(); } | @Test public void testGetClientList() { ClientList<Client> clients = reg.getClientList(); int listSize = clients.size(); Assert.assertTrue(listSize > 0); System.out.println("List size: " + listSize); for (int c = 0; c < listSize; c++) { Client client = clients.get(c); System.out.println(client); Assert.assertTrue(client.getId() != null); } } |
ClientRegistry implements IClientRegistry, ClientRegistryMBean { @SuppressWarnings("unchecked") protected Collection<IClient> getClients() { if (!hasClients()) { return Collections.EMPTY_SET; } return Collections.unmodifiableCollection(clients.values()); } ClientRegistry(); ClientRegistry(String name); Client getClient(String id); ClientList<Client> getClientList(); boolean hasClient(String id); IClient lookupClient(String id); IClient newClient(Object[] params); String nextId(); String previousId(); } | @Test public void testGetClients() { for (int c = 0; c < 10; c++) { reg.addClient(new Client(reg.nextId(), reg)); } Assert.assertNotNull(reg.getClient("2")); System.gc(); try { Thread.sleep(2000); System.gc(); } catch (InterruptedException e) { } Assert.assertTrue(reg.getClients().size() >= 10); } |
ClientRegistry implements IClientRegistry, ClientRegistryMBean { protected void removeClient(IClient client) { clients.remove(client.getId()); } ClientRegistry(); ClientRegistry(String name); Client getClient(String id); ClientList<Client> getClientList(); boolean hasClient(String id); IClient lookupClient(String id); IClient newClient(Object[] params); String nextId(); String previousId(); } | @Test public void testRemoveClient() { IClient client = reg.lookupClient("1"); Assert.assertNotNull(client); reg.removeClient(client); IClient client2 = null; try { client2 = reg.getClient("1"); fail("An exception should occur here"); } catch (ClientNotFoundException e) { Assert.assertTrue(true); } Assert.assertNull(client2); } |
XMLUtils { public static String docToString(Document dom) { return XMLUtils.docToString1(dom); } static Document stringToDoc(String str); static String docToString(Document dom); static String docToString1(Document dom); static String docToString2(Document domDoc); } | @Test @Ignore public void testDocToString() { fail("Not yet implemented"); } |
ConversionUtils { public static Object convert(Object source, Class<?> target) throws ConversionException { if (target == null) { throw new ConversionException("Unable to perform conversion, target was null"); } if (source == null) { if (target.isPrimitive()) { throw new ConversionException(String.format("Unable to convert null to primitive value of %s", target)); } return source; } else if ((source instanceof Float && ((Float) source).isNaN()) || (source instanceof Double && ((Double) source).isNaN())) { return source; } if (IConnection.class.isAssignableFrom(source.getClass()) && !target.equals(IConnection.class)) { throw new ConversionException("IConnection must match exactly"); } if (target.isInstance(source)) { return source; } if (target.isAssignableFrom(source.getClass())) { return source; } if (target.isArray()) { return convertToArray(source, target); } if (target.equals(String.class)) { return source.toString(); } if (target.isPrimitive()) { return convertToWrappedPrimitive(source, primitiveMap.get(target)); } if (wrapperMap.containsKey(target)) { return convertToWrappedPrimitive(source, target); } if (target.equals(Map.class)) { return convertBeanToMap(source); } if (target.equals(List.class) || target.equals(Collection.class)) { if (source.getClass().equals(LinkedHashMap.class)) { return convertMapToList((LinkedHashMap<?, ?>) source); } else if (source.getClass().isArray()) { return convertArrayToList((Object[]) source); } } if (target.equals(Set.class) && source.getClass().isArray()) { return convertArrayToSet((Object[]) source); } throw new ConversionException(String.format("Unable to preform conversion from %s to %s", source, target)); } static Object convert(Object source, Class<?> target); static Object convertToArray(Object source, Class<?> target); static List<Object> convertMapToList(Map<?, ?> map); static Object convertToWrappedPrimitive(Object source, Class<?> wrapper); static Object convertStringToWrapper(String str, Class<?> wrapper); static Object convertNumberToWrapper(Number num, Class<?> wrapper); static List<Method> findMethodsByNameAndNumParams(Object object,
String method, int numParam); static Object[] convertParams(Object[] source, Class<?>[] target); static Class<?>[] convertParams(Object[] source); static List<?> convertArrayToList(Object[] source); static Object convertMapToBean(Map<?, ?> source, Class<?> target); static Map<?, ?> convertBeanToMap(Object source); static Set<?> convertArrayToSet(Object[] source); } | @Test public void testBasic() { Object result = ConversionUtils.convert(new Integer(42), String.class); if (!(result instanceof String)) { fail("Should be a string"); } String str = (String) result; assertEquals("42", str); }
@Test public void testConvertListToStringArray() { ArrayList<String> source = new ArrayList<String>(); source.add("Testing 1"); source.add("Testing 2"); source.add("Testing 3"); Class<? extends String[]> target = (new String[0]).getClass(); Object result = ConversionUtils.convert(source, target); if (!(result.getClass().isArray() && result.getClass() .getComponentType().equals(String.class))) { fail("Should be String[]"); } String[] results = (String[]) result; assertEquals(results.length, source.size()); assertEquals(results[2], source.get(2)); }
@Test public void testConvertObjectArrayToStringArray() { Object[] source = new Object[3]; source[0] = new Integer(21); source[1] = Boolean.FALSE; source[2] = "Woot"; Class<? extends String[]> target = (new String[0]).getClass(); Object result = ConversionUtils.convert(source, target); if (!(result.getClass().isArray() && result.getClass() .getComponentType().equals(String.class))) { fail("Should be String[]"); } String[] results = (String[]) result; assertEquals(results.length, source.length); assertEquals(results[2], source[2]); }
@Test public void testConvertToSet() { Object[] source = new Object[3]; source[0] = new Integer(21); source[1] = Boolean.FALSE; source[2] = "Woot"; Object result = ConversionUtils.convert(source, Set.class); if (!(result instanceof Set)) { fail("Should be a set"); } Set<?> results = (Set<?>) result; assertEquals(results.size(), source.length); }
@Test public void testNoOppConvert() { TestJavaBean source = new TestJavaBean(); Object result = ConversionUtils.convert(source, TestJavaBean.class); assertEquals(result, source); }
@Test public void testNullConvert() { Object result = ConversionUtils.convert(null, TestJavaBean.class); assertNull(result); }
@Test(expected=ConversionException.class) public void testNullConvertNoClass() { ConversionUtils.convert(new TestJavaBean(), null); } |
StreamUtils { public static IServerStream createServerStream(IScope scope, String name) { logger.debug("Creating server stream: {} scope: {}", name, scope); ServerStream stream = new ServerStream(); stream.setScope(scope); stream.setName(name); stream.setPublishedName(name); String key = scope.getName() + '/' + name; serverStreamMap.put(key, stream); return stream; } static IServerStream createServerStream(IScope scope, String name); static IServerStream getServerStream(IScope scope, String name); static void putServerStream(IScope scope, String name, IServerStream stream); static void removeServerStream(IScope scope, String name); } | @Test public void testCreateServerStream() { System.out.println("Not yet implemented"); } |
StreamUtils { public static IServerStream getServerStream(IScope scope, String name) { logger.debug("Looking up server stream: {} scope: {}", name, scope); String key = scope.getName() + '/' + name; if (serverStreamMap.containsKey(key)) { return serverStreamMap.get(key); } else { logger.warn("Server stream not found with key: {}", key); return null; } } static IServerStream createServerStream(IScope scope, String name); static IServerStream getServerStream(IScope scope, String name); static void putServerStream(IScope scope, String name, IServerStream stream); static void removeServerStream(IScope scope, String name); } | @Test public void testGetServerStream() { System.out.println("Not yet implemented"); } |
PlaylistSubscriberStream extends AbstractClientStream implements
IPlaylistSubscriberStream, IPlaylistSubscriberStreamStatistics { public ScheduledThreadPoolExecutor getExecutor() { if (executor == null) { log.warn("ScheduledThreadPoolExecutor was null on request"); } return executor; } PlaylistSubscriberStream(); void setExecutor(ScheduledThreadPoolExecutor executor); ScheduledThreadPoolExecutor getExecutor(); void setBufferCheckInterval(int bufferCheckInterval); void setUnderrunTrigger(int underrunTrigger); void start(); void play(); void pause(int position); void resume(int position); void stop(); void seek(int position); void close(); boolean isPaused(); void addItem(IPlayItem item); void addItem(IPlayItem item, int index); void removeItem(int index); void removeAllItems(); void previousItem(); boolean hasMoreItems(); void nextItem(); void setItem(int index); boolean isRandom(); void setRandom(boolean random); boolean isRewind(); void setRewind(boolean rewind); boolean isRepeat(); void setRepeat(boolean repeat); void receiveVideo(boolean receive); void receiveAudio(boolean receive); void setPlaylistController(IPlaylistController controller); int getItemSize(); int getCurrentItemIndex(); IPlayItem getCurrentItem(); IPlayItem getItem(int index); void setBandwidthController(IBWControlService bwController); @Override void setBandwidthConfigure(IBandwidthConfigure config); void written(Object message); IPlaylistSubscriberStreamStatistics getStatistics(); long getCreationTime(); int getCurrentTimestamp(); long getBytesSent(); double getEstimatedBufferFill(); } | @Test public void testGetExecutor() { System.out.println("testGetExecutor"); assertTrue(pss.getExecutor() != null); } |
XMLUtils { public static String docToString1(Document dom) { StringWriter sw = new StringWriter(); DOM2Writer.serializeAsXML(dom, sw); return sw.toString(); } static Document stringToDoc(String str); static String docToString(Document dom); static String docToString1(Document dom); static String docToString2(Document domDoc); } | @Test @Ignore public void testDocToString1() { fail("Not yet implemented"); } |
PlaylistSubscriberStream extends AbstractClientStream implements
IPlaylistSubscriberStream, IPlaylistSubscriberStreamStatistics { public void start() { if (engine == null) { IScope scope = getScope(); if (scope != null) { IContext ctx = scope.getContext(); ISchedulingService schedulingService = (ISchedulingService) ctx.getBean(ISchedulingService.BEAN_NAME); IConsumerService consumerService = (IConsumerService) ctx.getBean(IConsumerService.KEY); IProviderService providerService = (IProviderService) ctx.getBean(IProviderService.BEAN_NAME); engine = new PlayEngine.Builder(this, schedulingService, consumerService, providerService).build(); } else { log.info("Scope was null on start"); } } if (bwController == null) { bwController = (IBWControlService) getScope().getContext().getBean(IBWControlService.KEY); } bwContext = bwController.registerBWControllable(this); engine.setBandwidthController(bwController, bwContext); engine.setBufferCheckInterval(bufferCheckInterval); engine.setUnderrunTrigger(underrunTrigger); engine.start(); notifySubscriberStart(); } PlaylistSubscriberStream(); void setExecutor(ScheduledThreadPoolExecutor executor); ScheduledThreadPoolExecutor getExecutor(); void setBufferCheckInterval(int bufferCheckInterval); void setUnderrunTrigger(int underrunTrigger); void start(); void play(); void pause(int position); void resume(int position); void stop(); void seek(int position); void close(); boolean isPaused(); void addItem(IPlayItem item); void addItem(IPlayItem item, int index); void removeItem(int index); void removeAllItems(); void previousItem(); boolean hasMoreItems(); void nextItem(); void setItem(int index); boolean isRandom(); void setRandom(boolean random); boolean isRewind(); void setRewind(boolean rewind); boolean isRepeat(); void setRepeat(boolean repeat); void receiveVideo(boolean receive); void receiveAudio(boolean receive); void setPlaylistController(IPlaylistController controller); int getItemSize(); int getCurrentItemIndex(); IPlayItem getCurrentItem(); IPlayItem getItem(int index); void setBandwidthController(IBWControlService bwController); @Override void setBandwidthConfigure(IBandwidthConfigure config); void written(Object message); IPlaylistSubscriberStreamStatistics getStatistics(); long getCreationTime(); int getCurrentTimestamp(); long getBytesSent(); double getEstimatedBufferFill(); } | @Test public void testStart() { System.out.println("testStart"); SimplePlayItem item = new SimplePlayItem(); item.setName("DarkKnight.flv"); pss.addItem(item); pss.start(); } |
PlaylistSubscriberStream extends AbstractClientStream implements
IPlaylistSubscriberStream, IPlaylistSubscriberStreamStatistics { public void play() throws IOException { int count = items.size(); if (count == 0) { return; } if (currentItemIndex == -1) { moveToNext(); } while (count-- > 0) { IPlayItem item = null; read.lock(); try { item = items.get(currentItemIndex); engine.play(item); break; } catch (StreamNotFoundException e) { moveToNext(); if (currentItemIndex == -1) { break; } item = items.get(currentItemIndex); } catch (IllegalStateException e) { break; } finally { read.unlock(); } } } PlaylistSubscriberStream(); void setExecutor(ScheduledThreadPoolExecutor executor); ScheduledThreadPoolExecutor getExecutor(); void setBufferCheckInterval(int bufferCheckInterval); void setUnderrunTrigger(int underrunTrigger); void start(); void play(); void pause(int position); void resume(int position); void stop(); void seek(int position); void close(); boolean isPaused(); void addItem(IPlayItem item); void addItem(IPlayItem item, int index); void removeItem(int index); void removeAllItems(); void previousItem(); boolean hasMoreItems(); void nextItem(); void setItem(int index); boolean isRandom(); void setRandom(boolean random); boolean isRewind(); void setRewind(boolean rewind); boolean isRepeat(); void setRepeat(boolean repeat); void receiveVideo(boolean receive); void receiveAudio(boolean receive); void setPlaylistController(IPlaylistController controller); int getItemSize(); int getCurrentItemIndex(); IPlayItem getCurrentItem(); IPlayItem getItem(int index); void setBandwidthController(IBWControlService bwController); @Override void setBandwidthConfigure(IBandwidthConfigure config); void written(Object message); IPlaylistSubscriberStreamStatistics getStatistics(); long getCreationTime(); int getCurrentTimestamp(); long getBytesSent(); double getEstimatedBufferFill(); } | @Test public void testPlay() throws Exception { System.out.println("testPlay"); pss.play(); } |
PlaylistSubscriberStream extends AbstractClientStream implements
IPlaylistSubscriberStream, IPlaylistSubscriberStreamStatistics { public void pause(int position) { try { engine.pause(position); } catch (IllegalStateException e) { log.debug("pause caught an IllegalStateException"); } } PlaylistSubscriberStream(); void setExecutor(ScheduledThreadPoolExecutor executor); ScheduledThreadPoolExecutor getExecutor(); void setBufferCheckInterval(int bufferCheckInterval); void setUnderrunTrigger(int underrunTrigger); void start(); void play(); void pause(int position); void resume(int position); void stop(); void seek(int position); void close(); boolean isPaused(); void addItem(IPlayItem item); void addItem(IPlayItem item, int index); void removeItem(int index); void removeAllItems(); void previousItem(); boolean hasMoreItems(); void nextItem(); void setItem(int index); boolean isRandom(); void setRandom(boolean random); boolean isRewind(); void setRewind(boolean rewind); boolean isRepeat(); void setRepeat(boolean repeat); void receiveVideo(boolean receive); void receiveAudio(boolean receive); void setPlaylistController(IPlaylistController controller); int getItemSize(); int getCurrentItemIndex(); IPlayItem getCurrentItem(); IPlayItem getItem(int index); void setBandwidthController(IBWControlService bwController); @Override void setBandwidthConfigure(IBandwidthConfigure config); void written(Object message); IPlaylistSubscriberStreamStatistics getStatistics(); long getCreationTime(); int getCurrentTimestamp(); long getBytesSent(); double getEstimatedBufferFill(); } | @Test public void testPause() { System.out.println("testPause"); long sent = pss.getBytesSent(); pss.pause((int) sent); } |
PlaylistSubscriberStream extends AbstractClientStream implements
IPlaylistSubscriberStream, IPlaylistSubscriberStreamStatistics { public void resume(int position) { try { engine.resume(position); } catch (IllegalStateException e) { log.debug("resume caught an IllegalStateException"); } } PlaylistSubscriberStream(); void setExecutor(ScheduledThreadPoolExecutor executor); ScheduledThreadPoolExecutor getExecutor(); void setBufferCheckInterval(int bufferCheckInterval); void setUnderrunTrigger(int underrunTrigger); void start(); void play(); void pause(int position); void resume(int position); void stop(); void seek(int position); void close(); boolean isPaused(); void addItem(IPlayItem item); void addItem(IPlayItem item, int index); void removeItem(int index); void removeAllItems(); void previousItem(); boolean hasMoreItems(); void nextItem(); void setItem(int index); boolean isRandom(); void setRandom(boolean random); boolean isRewind(); void setRewind(boolean rewind); boolean isRepeat(); void setRepeat(boolean repeat); void receiveVideo(boolean receive); void receiveAudio(boolean receive); void setPlaylistController(IPlaylistController controller); int getItemSize(); int getCurrentItemIndex(); IPlayItem getCurrentItem(); IPlayItem getItem(int index); void setBandwidthController(IBWControlService bwController); @Override void setBandwidthConfigure(IBandwidthConfigure config); void written(Object message); IPlaylistSubscriberStreamStatistics getStatistics(); long getCreationTime(); int getCurrentTimestamp(); long getBytesSent(); double getEstimatedBufferFill(); } | @Test public void testResume() { System.out.println("testResume"); long sent = pss.getBytesSent(); pss.resume((int) sent); } |
PlaylistSubscriberStream extends AbstractClientStream implements
IPlaylistSubscriberStream, IPlaylistSubscriberStreamStatistics { public void seek(int position) throws OperationNotSupportedException { try { engine.seek(position); } catch (IllegalStateException e) { log.debug("seek caught an IllegalStateException"); } } PlaylistSubscriberStream(); void setExecutor(ScheduledThreadPoolExecutor executor); ScheduledThreadPoolExecutor getExecutor(); void setBufferCheckInterval(int bufferCheckInterval); void setUnderrunTrigger(int underrunTrigger); void start(); void play(); void pause(int position); void resume(int position); void stop(); void seek(int position); void close(); boolean isPaused(); void addItem(IPlayItem item); void addItem(IPlayItem item, int index); void removeItem(int index); void removeAllItems(); void previousItem(); boolean hasMoreItems(); void nextItem(); void setItem(int index); boolean isRandom(); void setRandom(boolean random); boolean isRewind(); void setRewind(boolean rewind); boolean isRepeat(); void setRepeat(boolean repeat); void receiveVideo(boolean receive); void receiveAudio(boolean receive); void setPlaylistController(IPlaylistController controller); int getItemSize(); int getCurrentItemIndex(); IPlayItem getCurrentItem(); IPlayItem getItem(int index); void setBandwidthController(IBWControlService bwController); @Override void setBandwidthConfigure(IBandwidthConfigure config); void written(Object message); IPlaylistSubscriberStreamStatistics getStatistics(); long getCreationTime(); int getCurrentTimestamp(); long getBytesSent(); double getEstimatedBufferFill(); } | @Test public void testSeek() { System.out.println("testSeek"); long sent = pss.getBytesSent(); try { pss.seek((int) (sent * 2)); } catch (OperationNotSupportedException e) { e.printStackTrace(); } } |
PlaylistSubscriberStream extends AbstractClientStream implements
IPlaylistSubscriberStream, IPlaylistSubscriberStreamStatistics { public void addItem(IPlayItem item) { write.lock(); try { items.add(item); } finally { write.unlock(); } } PlaylistSubscriberStream(); void setExecutor(ScheduledThreadPoolExecutor executor); ScheduledThreadPoolExecutor getExecutor(); void setBufferCheckInterval(int bufferCheckInterval); void setUnderrunTrigger(int underrunTrigger); void start(); void play(); void pause(int position); void resume(int position); void stop(); void seek(int position); void close(); boolean isPaused(); void addItem(IPlayItem item); void addItem(IPlayItem item, int index); void removeItem(int index); void removeAllItems(); void previousItem(); boolean hasMoreItems(); void nextItem(); void setItem(int index); boolean isRandom(); void setRandom(boolean random); boolean isRewind(); void setRewind(boolean rewind); boolean isRepeat(); void setRepeat(boolean repeat); void receiveVideo(boolean receive); void receiveAudio(boolean receive); void setPlaylistController(IPlaylistController controller); int getItemSize(); int getCurrentItemIndex(); IPlayItem getCurrentItem(); IPlayItem getItem(int index); void setBandwidthController(IBWControlService bwController); @Override void setBandwidthConfigure(IBandwidthConfigure config); void written(Object message); IPlaylistSubscriberStreamStatistics getStatistics(); long getCreationTime(); int getCurrentTimestamp(); long getBytesSent(); double getEstimatedBufferFill(); } | @Test public void testAddItemIPlayItem() { System.out.println("testAddItemIPlayItem"); SimplePlayItem item = new SimplePlayItem(); item.setName("IronMan.flv"); pss.addItem(item); } |
PlaylistSubscriberStream extends AbstractClientStream implements
IPlaylistSubscriberStream, IPlaylistSubscriberStreamStatistics { public void previousItem() { stop(); moveToPrevious(); if (currentItemIndex == -1) { return; } IPlayItem item = null; int count = items.size(); while (count-- > 0) { read.lock(); try { item = items.get(currentItemIndex); engine.play(item); break; } catch (IOException err) { log.error("Error while starting to play item, moving to previous.", err); moveToPrevious(); if (currentItemIndex == -1) { break; } } catch (StreamNotFoundException e) { moveToPrevious(); if (currentItemIndex == -1) { break; } } catch (IllegalStateException e) { break; } finally { read.unlock(); } } } PlaylistSubscriberStream(); void setExecutor(ScheduledThreadPoolExecutor executor); ScheduledThreadPoolExecutor getExecutor(); void setBufferCheckInterval(int bufferCheckInterval); void setUnderrunTrigger(int underrunTrigger); void start(); void play(); void pause(int position); void resume(int position); void stop(); void seek(int position); void close(); boolean isPaused(); void addItem(IPlayItem item); void addItem(IPlayItem item, int index); void removeItem(int index); void removeAllItems(); void previousItem(); boolean hasMoreItems(); void nextItem(); void setItem(int index); boolean isRandom(); void setRandom(boolean random); boolean isRewind(); void setRewind(boolean rewind); boolean isRepeat(); void setRepeat(boolean repeat); void receiveVideo(boolean receive); void receiveAudio(boolean receive); void setPlaylistController(IPlaylistController controller); int getItemSize(); int getCurrentItemIndex(); IPlayItem getCurrentItem(); IPlayItem getItem(int index); void setBandwidthController(IBWControlService bwController); @Override void setBandwidthConfigure(IBandwidthConfigure config); void written(Object message); IPlaylistSubscriberStreamStatistics getStatistics(); long getCreationTime(); int getCurrentTimestamp(); long getBytesSent(); double getEstimatedBufferFill(); } | @Test public void testPreviousItem() { log.error("Not yet implemented -- get on that"); } |
PlaylistSubscriberStream extends AbstractClientStream implements
IPlaylistSubscriberStream, IPlaylistSubscriberStreamStatistics { public void nextItem() { moveToNext(); if (currentItemIndex == -1) { return; } IPlayItem item = null; int count = items.size(); while (count-- > 0) { read.lock(); try { item = items.get(currentItemIndex); engine.play(item, false); break; } catch (IOException err) { log.error("Error while starting to play item, moving to next", err); moveToNext(); if (currentItemIndex == -1) { break; } } catch (StreamNotFoundException e) { moveToNext(); if (currentItemIndex == -1) { break; } } catch (IllegalStateException e) { break; } finally { read.unlock(); } } } PlaylistSubscriberStream(); void setExecutor(ScheduledThreadPoolExecutor executor); ScheduledThreadPoolExecutor getExecutor(); void setBufferCheckInterval(int bufferCheckInterval); void setUnderrunTrigger(int underrunTrigger); void start(); void play(); void pause(int position); void resume(int position); void stop(); void seek(int position); void close(); boolean isPaused(); void addItem(IPlayItem item); void addItem(IPlayItem item, int index); void removeItem(int index); void removeAllItems(); void previousItem(); boolean hasMoreItems(); void nextItem(); void setItem(int index); boolean isRandom(); void setRandom(boolean random); boolean isRewind(); void setRewind(boolean rewind); boolean isRepeat(); void setRepeat(boolean repeat); void receiveVideo(boolean receive); void receiveAudio(boolean receive); void setPlaylistController(IPlaylistController controller); int getItemSize(); int getCurrentItemIndex(); IPlayItem getCurrentItem(); IPlayItem getItem(int index); void setBandwidthController(IBWControlService bwController); @Override void setBandwidthConfigure(IBandwidthConfigure config); void written(Object message); IPlaylistSubscriberStreamStatistics getStatistics(); long getCreationTime(); int getCurrentTimestamp(); long getBytesSent(); double getEstimatedBufferFill(); } | @Test public void testNextItem() { log.error("Not yet implemented -- get on that"); } |
PlaylistSubscriberStream extends AbstractClientStream implements
IPlaylistSubscriberStream, IPlaylistSubscriberStreamStatistics { public void setItem(int index) { if (index < 0 || index >= items.size()) { return; } stop(); currentItemIndex = index; read.lock(); try { IPlayItem item = items.get(currentItemIndex); engine.play(item); } catch (IOException e) { log.error("setItem caught a IOException", e); } catch (StreamNotFoundException e) { log.debug("setItem caught a StreamNotFoundException"); } catch (IllegalStateException e) { log.error("Illegal state exception on playlist item setup", e); } finally { read.unlock(); } } PlaylistSubscriberStream(); void setExecutor(ScheduledThreadPoolExecutor executor); ScheduledThreadPoolExecutor getExecutor(); void setBufferCheckInterval(int bufferCheckInterval); void setUnderrunTrigger(int underrunTrigger); void start(); void play(); void pause(int position); void resume(int position); void stop(); void seek(int position); void close(); boolean isPaused(); void addItem(IPlayItem item); void addItem(IPlayItem item, int index); void removeItem(int index); void removeAllItems(); void previousItem(); boolean hasMoreItems(); void nextItem(); void setItem(int index); boolean isRandom(); void setRandom(boolean random); boolean isRewind(); void setRewind(boolean rewind); boolean isRepeat(); void setRepeat(boolean repeat); void receiveVideo(boolean receive); void receiveAudio(boolean receive); void setPlaylistController(IPlaylistController controller); int getItemSize(); int getCurrentItemIndex(); IPlayItem getCurrentItem(); IPlayItem getItem(int index); void setBandwidthController(IBWControlService bwController); @Override void setBandwidthConfigure(IBandwidthConfigure config); void written(Object message); IPlaylistSubscriberStreamStatistics getStatistics(); long getCreationTime(); int getCurrentTimestamp(); long getBytesSent(); double getEstimatedBufferFill(); } | @Test public void testSetItem() { log.error("Not yet implemented -- get on that"); } |
PlaylistSubscriberStream extends AbstractClientStream implements
IPlaylistSubscriberStream, IPlaylistSubscriberStreamStatistics { public void stop() { try { engine.stop(); } catch (IllegalStateException e) { log.debug("stop caught an IllegalStateException"); } } PlaylistSubscriberStream(); void setExecutor(ScheduledThreadPoolExecutor executor); ScheduledThreadPoolExecutor getExecutor(); void setBufferCheckInterval(int bufferCheckInterval); void setUnderrunTrigger(int underrunTrigger); void start(); void play(); void pause(int position); void resume(int position); void stop(); void seek(int position); void close(); boolean isPaused(); void addItem(IPlayItem item); void addItem(IPlayItem item, int index); void removeItem(int index); void removeAllItems(); void previousItem(); boolean hasMoreItems(); void nextItem(); void setItem(int index); boolean isRandom(); void setRandom(boolean random); boolean isRewind(); void setRewind(boolean rewind); boolean isRepeat(); void setRepeat(boolean repeat); void receiveVideo(boolean receive); void receiveAudio(boolean receive); void setPlaylistController(IPlaylistController controller); int getItemSize(); int getCurrentItemIndex(); IPlayItem getCurrentItem(); IPlayItem getItem(int index); void setBandwidthController(IBWControlService bwController); @Override void setBandwidthConfigure(IBandwidthConfigure config); void written(Object message); IPlaylistSubscriberStreamStatistics getStatistics(); long getCreationTime(); int getCurrentTimestamp(); long getBytesSent(); double getEstimatedBufferFill(); } | @Test public void testStop() { System.out.println("testStop"); pss.stop(); } |
XMLUtils { public static String docToString2(Document domDoc) throws IOException { try { TransformerFactory transFact = TransformerFactory.newInstance(); Transformer trans = transFact.newTransformer(); trans.setOutputProperty(OutputKeys.INDENT, "no"); StringWriter sw = new StringWriter(); Result result = new StreamResult(sw); trans.transform(new DOMSource(domDoc), result); return sw.toString(); } catch (Exception ex) { throw new IOException(String.format("Error converting from doc to string %s", ex.getMessage())); } } static Document stringToDoc(String str); static String docToString(Document dom); static String docToString1(Document dom); static String docToString2(Document domDoc); } | @Test @Ignore public void testDocToString2() { fail("Not yet implemented"); } |
PlaylistSubscriberStream extends AbstractClientStream implements
IPlaylistSubscriberStream, IPlaylistSubscriberStreamStatistics { public void close() { engine.close(); bwController.unregisterBWControllable(bwContext); notifySubscriberClose(); } PlaylistSubscriberStream(); void setExecutor(ScheduledThreadPoolExecutor executor); ScheduledThreadPoolExecutor getExecutor(); void setBufferCheckInterval(int bufferCheckInterval); void setUnderrunTrigger(int underrunTrigger); void start(); void play(); void pause(int position); void resume(int position); void stop(); void seek(int position); void close(); boolean isPaused(); void addItem(IPlayItem item); void addItem(IPlayItem item, int index); void removeItem(int index); void removeAllItems(); void previousItem(); boolean hasMoreItems(); void nextItem(); void setItem(int index); boolean isRandom(); void setRandom(boolean random); boolean isRewind(); void setRewind(boolean rewind); boolean isRepeat(); void setRepeat(boolean repeat); void receiveVideo(boolean receive); void receiveAudio(boolean receive); void setPlaylistController(IPlaylistController controller); int getItemSize(); int getCurrentItemIndex(); IPlayItem getCurrentItem(); IPlayItem getItem(int index); void setBandwidthController(IBWControlService bwController); @Override void setBandwidthConfigure(IBandwidthConfigure config); void written(Object message); IPlaylistSubscriberStreamStatistics getStatistics(); long getCreationTime(); int getCurrentTimestamp(); long getBytesSent(); double getEstimatedBufferFill(); } | @Test public void testClose() { System.out.println("testClose"); pss.close(); } |
Scope extends BasicScope implements IScope, IScopeStatistics,
ScopeMBean { public Scope() { this(null); } Scope(); Scope(String name); boolean addChildScope(IBasicScope scope); boolean connect(IConnection conn); boolean connect(IConnection conn, Object[] params); boolean createChildScope(String name); void destroy(); void disconnect(IConnection conn); @Override void dispatchEvent(IEvent event); int getActiveClients(); int getActiveConnections(); int getActiveSubscopes(); IBasicScope getBasicScope(String type, String name); Iterator<String> getBasicScopeNames(String type); ClassLoader getClassLoader(); Set<IClient> getClients(); Collection<Set<IConnection>> getConnections(); IContext getContext(); String getContextPath(); long getCreationTime(); @Override int getDepth(); IScopeHandler getHandler(); int getMaxClients(); int getMaxConnections(); int getMaxSubscopes(); @Override IScope getParent(); @Override String getPath(); Resource getResource(String path); Resource[] getResources(String path); IScope getScope(String name); Iterator<String> getScopeNames(); Object getServiceHandler(String name); @SuppressWarnings("unchecked") Set<String> getServiceHandlerNames(); IScopeStatistics getStatistics(); int getTotalClients(); int getTotalConnections(); int getTotalSubscopes(); @Override boolean handleEvent(IEvent event); boolean hasChildScope(String name); boolean hasChildScope(String type, String name); boolean hasContext(); boolean hasHandler(); @Override boolean hasParent(); void init(); void uninit(); boolean isEnabled(); boolean getEnabled(); boolean isRunning(); boolean getRunning(); @Override Iterator<IBasicScope> iterator(); Set<IConnection> lookupConnections(IClient client); void registerServiceHandler(String name, Object handler); void removeChildScope(IBasicScope scope); void setAutoStart(boolean autoStart); void setChildLoadPath(String pattern); void setContext(IContext context); void setDepth(int depth); void setEnabled(boolean enabled); void setHandler(IScopeHandler handler); @Override void setName(String name); void setParent(IScope parent); void setPersistenceClass(String persistenceClass); boolean start(); void stop(); @Override String toString(); void unregisterServiceHandler(String name); IServer getServer(); void lock(); void unlock(); } | @Test public void testScope() { if (appScope == null) { appScope = (WebScope) applicationContext.getBean("web.scope"); log.debug("Application / web scope: {}", appScope); } TestCase.assertTrue(appScope.createChildScope("room1")); IScope room1 = appScope.getScope("room1"); log.debug("Room 1: {}", room1); IContext rmCtx1 = room1.getContext(); log.debug("Context 1: {}", rmCtx1); TestCase.assertTrue(room1.createChildScope("room2")); IScope room2 = room1.getScope("room2"); log.debug("Room 2: {}", room2); IContext rmCtx2 = room2.getContext(); log.debug("Context 2: {}", rmCtx2); TestCase.assertTrue(room2.createChildScope("room3")); IScope room3 = room2.getScope("room3"); log.debug("Room 3: {}", room3); IContext rmCtx3 = room3.getContext(); log.debug("Context 3: {}", rmCtx3); TestCase.assertTrue(room1.createChildScope("room4")); IScope room4 = room1.getScope("room4"); log.debug("Room 4: {}", room4); IContext rmCtx4 = room4.getContext(); log.debug("Context 4: {}", rmCtx4); TestCase.assertTrue(room4.createChildScope("room5")); IScope room5 = room4.getScope("room5"); log.debug("Room 5: {}", room5); IContext rmCtx5 = room5.getContext(); log.debug("Context 5: {}", rmCtx5); } |
ExtendedPropertyPlaceholderConfigurer extends PropertyPlaceholderConfigurer { public Properties getMergedProperties() { return mergedProperties; } Properties getMergedProperties(); void setWildcardLocations( String[] locations ); static synchronized void addGlobalProperty( String key, String val ); } | @Test public void testLocationsProperty() { ExtendedPropertyPlaceholderConfigurer configurer = (ExtendedPropertyPlaceholderConfigurer)context.getBean( "boringPlaceholderConfig" ); assertEquals( testProperties, configurer.getMergedProperties() ); }
@Test public void testWildcardLocationsProperty() { ExtendedPropertyPlaceholderConfigurer configurer = (ExtendedPropertyPlaceholderConfigurer)context.getBean( "wildcard1PlaceholderConfig" ); Properties mergedProp = new Properties(); mergedProp.putAll( testProperties ); mergedProp.putAll( testAProperties ); mergedProp.putAll( testBProperties ); assertEquals( mergedProp, configurer.getMergedProperties() ); configurer = (ExtendedPropertyPlaceholderConfigurer)context.getBean( "wildcard2PlaceholderConfig" ); mergedProp = new Properties(); mergedProp.putAll( testAProperties ); mergedProp.putAll( testBProperties ); mergedProp.putAll( testProperties ); assertEquals( mergedProp, configurer.getMergedProperties() ); }
@Test public void testLocationsPropertyOverridesWildcardLocationsProperty() { ExtendedPropertyPlaceholderConfigurer configurer = (ExtendedPropertyPlaceholderConfigurer)context.getBean( "locationsOverridesWildcardLocationsPlaceholderConfig" ); Properties mergedProp = new Properties(); mergedProp.putAll( testProperties ); assertEquals( mergedProp, configurer.getMergedProperties() ); } |
HMAC { public byte[] computeMac() { Mac hm = null; byte[] result = null; if (log.isDebugEnabled()) { log.debug("Key data: {}", byteArrayToHex(keyBytes)); log.debug("Hash data: {}", byteArrayToHex(dataBytes)); log.debug("Algorithm: {}", ALGORITHM_ID); } try { hm = Mac.getInstance(ALGORITHM_ID); Key k1 = new SecretKeySpec(keyBytes, 0, keyBytes.length, ALGORITHM_ID); hm.init(k1); result = hm.doFinal(dataBytes); } catch (Exception e) { log.warn("Bad algorithm or crypto library problem", e); } return result; } static final boolean isHexStringChar(char c); static final boolean isHex(String sampleData); static final boolean isHex(byte[] sampleData, int len); static final byte[] hexToByteArray(String str, boolean rev); static final String byteArrayToHex(byte[] a); byte[] readDataFile(File f, int minValidLength); byte[] readDataStream(InputStream is, int minValidLength); byte[] computeMac(); static final String ALGORITHM_ID; static final int MIN_LENGTH; static final int BUF_LENGTH; } | @Test public void testHMAC() { HMAC h1 = new HMAC(); assertNotNull(h1); try { Provider sp = new com.sun.crypto.provider.SunJCE(); Security.addProvider(sp); } catch (Exception e) { fail("Problem loading crypto provider" + e); } byte[] hmac = h1.computeMac(); assertNull("Currently HMAC is broken since you can't actually " + "set the keyData or data elements. This test will break once someone fixes that", hmac); } |
JMXAgent implements NotificationListener { public void init() { HashMap<String, Object> env = null; if (enableRmiAdapter) { log.debug("Create an RMI connector server"); System.setProperty("java.rmi.server.hostname", rmiAdapterHost); try { Registry r = null; try { r = LocateRegistry.getRegistry(Integer .valueOf(rmiAdapterPort)); for (String regName : r.list()) { if (regName.equals("red5")) { r.unbind("red5"); } } } catch (RemoteException re) { log.info("RMI Registry server was not found on port " + rmiAdapterPort); if (startRegistry) { log.info("Starting an internal RMI registry"); r = LocateRegistry.createRegistry(Integer .valueOf(rmiAdapterPort)); } } JMXServiceURL url = null; if (StringUtils.isNotEmpty(rmiAdapterRemotePort)) { url = new JMXServiceURL("service:jmx:rmi: + rmiAdapterHost + ":" + rmiAdapterRemotePort + "/jndi/rmi: } else { url = new JMXServiceURL( "service:jmx:rmi: + "/red5"); } log.info("JMXServiceUrl is: {}", url); if (enableSsl) { System.setProperty("javax.net.ssl.keyStore", remoteSSLKeystore); System.setProperty("javax.net.ssl.keyStorePassword", remoteSSLKeystorePass); log.debug("Initialize the environment map"); env = new HashMap<String, Object>(); SslRMIClientSocketFactory csf = new SslRMIClientSocketFactory(); SslRMIServerSocketFactory ssf = new SslRMIServerSocketFactory(); env .put( RMIConnectorServer.RMI_CLIENT_SOCKET_FACTORY_ATTRIBUTE, csf); env .put( RMIConnectorServer.RMI_SERVER_SOCKET_FACTORY_ATTRIBUTE, ssf); } if (StringUtils.isNotBlank(remoteAccessProperties)) { if (null == env) { env = new HashMap<String, Object>(); } File file = new File(remoteAccessProperties); if (!file.exists() && remoteAccessProperties.indexOf(System.getProperty("red5.config_root")) != 0) { log.debug("Access file was not found on path, will prepend config_root"); remoteAccessProperties = System .getProperty("red5.config_root") + '/' + remoteAccessProperties; remotePasswordProperties = System .getProperty("red5.config_root") + '/' + remotePasswordProperties; } env.put("jmx.remote.x.access.file", remoteAccessProperties); env.put("jmx.remote.x.password.file", remotePasswordProperties); } cs = JMXConnectorServerFactory.newJMXConnectorServer(url, env, mbs); cs.addNotificationListener(this, null, null); log.debug("Start the RMI connector server"); cs.start(); log.info("JMX RMI connector server successfully started"); } catch (ConnectException e) { log .warn("Could not establish RMI connection to port " + rmiAdapterPort + ", please make sure \"rmiregistry\" is running and configured to listen on this port."); } catch (IOException e) { String errMsg = e.getMessage(); if (errMsg.indexOf("NameAlreadyBoundException") != -1) { log .error("JMX connector (red5) already registered, you will need to restart your rmiregistry"); } else { log.error("{}", e); } } catch (Exception e) { log.error("Error in setup of JMX subsystem (RMI connector)", e); } } else { log.info("JMX RMI adapter was not enabled"); } } static String trimClassName(String className); @SuppressWarnings("unchecked") static boolean registerMBean(Object instance, String className,
Class interfaceClass); @SuppressWarnings("unchecked") static boolean registerMBean(Object instance, String className,
Class interfaceClass, ObjectName name); @SuppressWarnings("unchecked") static boolean registerMBean(Object instance, String className,
Class interfaceClass, String name); static void shutdown(); static boolean unregisterMBean(ObjectName oName); static boolean updateMBeanAttribute(ObjectName oName, String key,
int value); static boolean updateMBeanAttribute(ObjectName oName, String key,
String value); void handleNotification(Notification notification, Object handback); void init(); void setEnableRmiAdapter(boolean enableRmiAdapter); void setEnableRmiAdapter(String enableRmiAdapterString); void setEnableSsl(boolean enableSsl); void setEnableSsl(String enableSslString); void setRemoteAccessProperties(String remoteAccessProperties); void setRemotePasswordProperties(String remotePasswordProperties); void setRemoteSSLKeystore(String remoteSSLKeystore); void setRemoteSSLKeystorePass(String remoteSSLKeystorePass); void setRmiAdapterRemotePort(String rmiAdapterRemotePort); void setRmiAdapterPort(String rmiAdapterPort); void setRmiAdapterHost(String rmiAdapterHost); void setStartRegistry(boolean startRegistry); void setEnableMinaMonitor(boolean enableMinaMonitor); void setEnableMinaMonitor(String enableMinaMonitor); static boolean isEnableMinaMonitor(); } | @Test public void testInit() { System.out.println("Not yet implemented"); } |
JMXAgent implements NotificationListener { public static boolean unregisterMBean(ObjectName oName) { boolean unregistered = false; if (null != oName) { try { if (mbs.isRegistered(oName)) { log.debug("Mbean is registered"); mbs.unregisterMBean(oName); unregistered = !mbs.isRegistered(oName); } else { log.debug("Mbean is not currently registered"); } } catch (Exception e) { log.warn("Exception unregistering mbean {}", e); } } log.debug("leaving unregisterMBean..."); return unregistered; } static String trimClassName(String className); @SuppressWarnings("unchecked") static boolean registerMBean(Object instance, String className,
Class interfaceClass); @SuppressWarnings("unchecked") static boolean registerMBean(Object instance, String className,
Class interfaceClass, ObjectName name); @SuppressWarnings("unchecked") static boolean registerMBean(Object instance, String className,
Class interfaceClass, String name); static void shutdown(); static boolean unregisterMBean(ObjectName oName); static boolean updateMBeanAttribute(ObjectName oName, String key,
int value); static boolean updateMBeanAttribute(ObjectName oName, String key,
String value); void handleNotification(Notification notification, Object handback); void init(); void setEnableRmiAdapter(boolean enableRmiAdapter); void setEnableRmiAdapter(String enableRmiAdapterString); void setEnableSsl(boolean enableSsl); void setEnableSsl(String enableSslString); void setRemoteAccessProperties(String remoteAccessProperties); void setRemotePasswordProperties(String remotePasswordProperties); void setRemoteSSLKeystore(String remoteSSLKeystore); void setRemoteSSLKeystorePass(String remoteSSLKeystorePass); void setRmiAdapterRemotePort(String rmiAdapterRemotePort); void setRmiAdapterPort(String rmiAdapterPort); void setRmiAdapterHost(String rmiAdapterHost); void setStartRegistry(boolean startRegistry); void setEnableMinaMonitor(boolean enableMinaMonitor); void setEnableMinaMonitor(String enableMinaMonitor); static boolean isEnableMinaMonitor(); } | @Test public void testUnregisterMBean() throws Exception { logger.info("Default jmx domain: {}", JMXFactory.getDefaultDomain()); JMXAgent agent = new JMXAgent(); agent.init(); MBeanServer mbs = JMXFactory.getMBeanServer(); ObjectName oName = JMXFactory.createMBean( "org.red5.server.net.rtmp.RTMPMinaConnection", "connectionType=persistent,host=10.0.0.1,port=1935,clientId=1"); assertNotNull(oName); ObjectName oName2 = new ObjectName( "org.red5.server:type=RTMPMinaConnection,connectionType=persistent,host=10.0.0.2,port=1935,clientId=2"); logger.info("Register check 1: {}", mbs.isRegistered(oName)); assertTrue(JMXAgent.unregisterMBean(oName)); logger.info("Register check 2: {}", mbs.isRegistered(oName)); assertFalse(JMXAgent.unregisterMBean(oName)); logger.info("Register check 3: {}", mbs.isRegistered(oName2)); assertFalse(JMXAgent.unregisterMBean(oName2)); } |
JMXFactory { public static ObjectName createMBean(String className, String attributes) { log.info("Create the {} MBean within the MBeanServer", className); ObjectName objectName = null; try { StringBuilder objectNameStr = new StringBuilder(domain); objectNameStr.append(":type="); objectNameStr.append(className .substring(className.lastIndexOf(".") + 1)); objectNameStr.append(","); objectNameStr.append(attributes); log.info("ObjectName = {}", objectNameStr); objectName = new ObjectName(objectNameStr.toString()); if (!mbs.isRegistered(objectName)) { mbs.createMBean(className, objectName); } else { log.debug("MBean has already been created: {}", objectName); } } catch (Exception e) { log.error("Could not create the {} MBean. {}", className, e); } return objectName; } static ObjectName createMBean(String className, String attributes); static ObjectName createObjectName(String... strings); static ObjectName createSimpleMBean(String className,
String objectNameStr); static String getDefaultDomain(); static MBeanServer getMBeanServer(); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass, ObjectName name); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass, String name); String getDomain(); void setDomain(String domain); } | @Test public void testCreateMBean() { ObjectName objectName = null; try { objectName = JMXFactory.createMBean( "org.red5.server.jmx.JMXFactoryTest", "test=1"); assertNotNull(objectName); objectName = JMXFactory.createMBean( "org.red5.server.jmx.JMXFactoryTest", "test=2"); assertNotNull(objectName); objectName = JMXFactory.createMBean( "org.red5.server.jmx.JMXFactoryTest", "test=1"); assertNotNull(objectName); } catch (Exception e) { fail("Exception occured"); } } |
JMXFactory { public static ObjectName createSimpleMBean(String className, String objectNameStr) { log.info("Create the {} MBean within the MBeanServer", className); log.info("ObjectName = {}", objectNameStr); try { ObjectName objectName = ObjectName.getInstance(objectNameStr); if (!mbs.isRegistered(objectName)) { mbs.createMBean(className, objectName); } else { log.debug("MBean has already been created: {}", objectName); } return objectName; } catch (Exception e) { log.error("Could not create the {} MBean. {}", className, e); } return null; } static ObjectName createMBean(String className, String attributes); static ObjectName createObjectName(String... strings); static ObjectName createSimpleMBean(String className,
String objectNameStr); static String getDefaultDomain(); static MBeanServer getMBeanServer(); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass, ObjectName name); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass, String name); String getDomain(); void setDomain(String domain); } | @Test public void testCreateSimpleMBean() { System.out.println("Not yet implemented"); } |
JMXFactory { public static String getDefaultDomain() { return domain; } static ObjectName createMBean(String className, String attributes); static ObjectName createObjectName(String... strings); static ObjectName createSimpleMBean(String className,
String objectNameStr); static String getDefaultDomain(); static MBeanServer getMBeanServer(); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass, ObjectName name); @SuppressWarnings("unchecked") static boolean registerNewMBean(String className,
Class interfaceClass, String name); String getDomain(); void setDomain(String domain); } | @Test public void testGetDefaultDomain() { System.out.println("Not yet implemented"); } |
PhysicsUnit implements Unit<Q>, XMLSerializable { public static PhysicsUnit<?> valueOf(CharSequence charSequence) { return UCUMFormat.getCaseSensitiveInstance().parse(charSequence, new ParsePosition(0)); } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testValueOf() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public final UnitConverter getConverterToAny(Unit<?> that) throws IncommensurableException, UnconvertibleException { if (!isCompatible(that)) throw new IncommensurableException(this + " is not compatible with " + that); PhysicsUnit thatPhysics = (PhysicsUnit)that; DimensionalModel model = DimensionalModel.getCurrent(); PhysicsUnit thisSystemUnit = this.getSystemUnit(); UnitConverter thisToDimension = model.getDimensionalTransform(thisSystemUnit.getDimension()).concatenate(this.getConverterToSI()); PhysicsUnit thatSystemUnit = thatPhysics.getSystemUnit(); UnitConverter thatToDimension = model.getDimensionalTransform(thatSystemUnit.getDimension()).concatenate(thatPhysics.getConverterToSI()); return thatToDimension.inverse().concatenate(thisToDimension); } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testGetConverterToAny() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public final PhysicsUnit<?> alternate(String symbol) { return new AlternateUnit(this, symbol); } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testAlternate() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public final PhysicsUnit<Q> transform(UnitConverter operation) { PhysicsUnit<Q> systemUnit = this.getSystemUnit(); UnitConverter cvtr = this.getConverterToSI().concatenate(operation); if (cvtr.equals(PhysicsConverter.IDENTITY)) return systemUnit; return new TransformedUnit<Q>(systemUnit, cvtr); } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testTransform() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public final PhysicsUnit<Q> add(double offset) { if (offset == 0) return this; return transform(new AddConverter(offset)); } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testAdd() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public final PhysicsUnit<?> inverse() { if (this.equals(SI.ONE)) return this; return ProductUnit.getQuotientInstance(SI.ONE, this); } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testInverse() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public final PhysicsUnit<?> root(int n) { if (n > 0) return ProductUnit.getRootInstance(this, n); else if (n == 0) throw new ArithmeticException("Root's order of zero"); else return SI.ONE.divide(this.root(-n)); } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testRoot() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public final PhysicsUnit<?> pow(int n) { if (n > 0) return this.multiply(this.pow(n - 1)); else if (n == 0) return SI.ONE; else return SI.ONE.divide(this.pow(-n)); } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testPow() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public abstract int hashCode(); protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testHashCode() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public abstract boolean equals(Object that); protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testEquals() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { public AnnotatedUnit<Q> annotate(String annotation) { return new AnnotatedUnit<Q>(this, annotation); } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testAnnotate() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public String toString() { TextBuilder tmp = TextBuilder.newInstance(); try { return UCUMFormat.getCaseSensitiveInstance().format(this, tmp).toString(); } catch (IOException ioException) { throw new Error(ioException); } finally { TextBuilder.recycle(tmp); } } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testToString() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public String getSymbol() { return null; } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testGetSymbol() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public final PhysicsUnit<Q> getSystemUnit() { return toSI(); } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testGetSystemUnit() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testGetProductUnits() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public abstract PhysicsDimension getDimension(); protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testGetDimension() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public final boolean isCompatible(Unit<?> that) { if ((this == that) || this.equals(that)) return true; if (!(that instanceof PhysicsUnit)) return false; PhysicsDimension thisDimension = this.getDimension(); PhysicsDimension thatDimension = ((PhysicsUnit)that).getDimension(); if (thisDimension.equals(thatDimension)) return true; DimensionalModel model = DimensionalModel.getCurrent(); return model.getFundamentalDimension(thisDimension).equals(model.getFundamentalDimension(thatDimension)); } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testIsCompatible() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public final <T extends Quantity<T>> PhysicsUnit<T> asType(Class<T> type) { PhysicsDimension typeDimension = PhysicsDimension.getDimension(type); if ((typeDimension != null) && (!this.getDimension().equals(typeDimension))) throw new ClassCastException("The unit: " + this + " is not compatible with quantities of type " + type); return (PhysicsUnit<T>) this; } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testAsType() { } |
PhysicsUnit implements Unit<Q>, XMLSerializable { @Override public final UnitConverter getConverterTo(Unit<Q> that) throws UnconvertibleException { if ((this == that) || this.equals(that)) return PhysicsConverter.IDENTITY; Unit<Q> thisSystemUnit = this.getSystemUnit(); Unit<Q> thatSystemUnit = that.getSystemUnit(); if (!thisSystemUnit.equals(thatSystemUnit)) return getConverterToAny(that); UnitConverter thisToSI= this.getConverterToSI(); UnitConverter thatToSI= that.getConverterTo(thatSystemUnit); return thatToSI.inverse().concatenate(thisToSI); } protected PhysicsUnit(); boolean isSI(); abstract PhysicsUnit<Q> toSI(); abstract UnitConverter getConverterToSI(); AnnotatedUnit<Q> annotate(String annotation); static PhysicsUnit<?> valueOf(CharSequence charSequence); @Override String toString(); @Override final PhysicsUnit<Q> getSystemUnit(); @Override final boolean isCompatible(Unit<?> that); @Override final PhysicsUnit<T> asType(Class<T> type); @Override String getSymbol(); @Override abstract Map<? extends PhysicsUnit, Integer> getProductUnits(); @Override abstract PhysicsDimension getDimension(); @Override final UnitConverter getConverterTo(Unit<Q> that); @Override final UnitConverter getConverterToAny(Unit<?> that); @Override final PhysicsUnit<?> alternate(String symbol); @Override final PhysicsUnit<Q> transform(UnitConverter operation); @Override final PhysicsUnit<Q> add(double offset); @Override final PhysicsUnit<Q> multiply(double factor); @Override final Unit<?> multiply(Unit<?> that); final PhysicsUnit<?> multiply(PhysicsUnit<?> that); @Override final PhysicsUnit<?> inverse(); @Override final PhysicsUnit<Q> divide(double divisor); @Override final Unit<?> divide(Unit<?> that); final PhysicsUnit<?> divide(PhysicsUnit<?> that); @Override final PhysicsUnit<?> root(int n); @Override final PhysicsUnit<?> pow(int n); @Override abstract int hashCode(); @Override abstract boolean equals(Object that); } | @Test public void testGetConverterTo() { } |
SpansToDependencyLinks implements Function<Iterable<Span>, Iterable<Dependency>> { protected Optional<Dependency> sharedSpanDependency(Set<Span> sharedSpans) { String clientService = null; String serverService = null; for (Span span: sharedSpans) { for (KeyValue tag: span.getTags()) { if (Tags.SPAN_KIND_CLIENT.equals(tag.getValueString()) || Tags.SPAN_KIND_PRODUCER.equals(tag.getValueString())) { clientService = span.getProcess().getServiceName(); } else if (Tags.SPAN_KIND_SERVER.equals(tag.getValueString()) || Tags.SPAN_KIND_CONSUMER.equals(tag.getValueString())) { serverService = span.getProcess().getServiceName(); } if (clientService != null && serverService != null) { return Optional.of(new Dependency(clientService, serverService)); } } } return Optional.empty(); } SpansToDependencyLinks(String peerServiceTag); @Override Iterable<Dependency> call(Iterable<Span> trace); public String peerServiceTag; } | @Test public void shouldReturnDependencyWithClientAndServerSpans() { SpansToDependencyLinks spansToDependencyLinks = new SpansToDependencyLinks(""); Set<Span> sharedSpans = new HashSet<>(); sharedSpans.add(createSpan("clientName", Tags.SPAN_KIND_CLIENT)); sharedSpans.add(createSpan("serverName", Tags.SPAN_KIND_SERVER)); Optional<Dependency> result = spansToDependencyLinks.sharedSpanDependency(sharedSpans); assertTrue(result.isPresent()); assertEquals(new Dependency("clientName", "serverName"), result.get()); }
@Test public void shouldReturnDependencyWithConsumerAndProducer() { SpansToDependencyLinks spansToDependencyLinks = new SpansToDependencyLinks(""); Set<Span> sharedSpans = new HashSet<>(); sharedSpans.add(createSpan("consumerName", Tags.SPAN_KIND_CONSUMER)); sharedSpans.add(createSpan("producerName", Tags.SPAN_KIND_PRODUCER)); Optional<Dependency> result = spansToDependencyLinks.sharedSpanDependency(sharedSpans); assertTrue(result.isPresent()); assertEquals(new Dependency("producerName", "consumerName"), result.get()); }
@Test public void shouldReturnEmptyDependencyForSpansWithoutSpanKindDefinition() { SpansToDependencyLinks spansToDependencyLinks = new SpansToDependencyLinks(""); Set<Span> sharedSpans = new HashSet<>(); sharedSpans.add(createSpan("consumerName", "tag")); sharedSpans.add(createSpan("producerName", "tag")); Optional<Dependency> result = spansToDependencyLinks.sharedSpanDependency(sharedSpans); assertFalse(result.isPresent()); } |
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } static SerializationMetadata extractMetadata(List<Field> fields); static SerializationMetadata extractMetadataForPartialCopy(List<Field> fields); } | @Test public void primitives1Metadata() { unsafeClassHeaderSize64BitCompressedOops(new Primitives1()); SerializationMetadata serializationMetadata = extractMetadata(Introspect.fields(Primitives1.class)); assertEquals(OBJECT_HEADER_SIZE, serializationMetadata.start); assertEquals(4, serializationMetadata.length); }
@Test public void primitives2Metadata() { unsafeClassHeaderSize64BitCompressedOops(new Primitives2()); SerializationMetadata serializationMetadata = extractMetadata(Introspect.fields(Primitives2.class)); assertEquals(OBJECT_HEADER_SIZE, serializationMetadata.start); assertEquals(12, serializationMetadata.length); }
@Test public void primitives3Metadata() { unsafeClassHeaderSize64BitCompressedOops(new Primitives3()); SerializationMetadata serializationMetadata = extractMetadata(Introspect.fields(Primitives3.class)); assertEquals(OBJECT_HEADER_SIZE, serializationMetadata.start); assertEquals(12, serializationMetadata.length); }
@Test public void primitives4Metadata() { unsafeClassHeaderSize64BitCompressedOops(new Primitives4()); SerializationMetadata serializationMetadata = extractMetadata(Introspect.fields(Primitives4.class)); assertEquals(OBJECT_HEADER_SIZE, serializationMetadata.start); assertEquals(4, serializationMetadata.length); }
@Test public void primitives5Metadata() { unsafeClassHeaderSize64BitCompressedOops(new Primitives5()); SerializationMetadata serializationMetadata = extractMetadata(Introspect.fields(Primitives5.class)); assertEquals(OBJECT_HEADER_SIZE, serializationMetadata.start); assertEquals(12, serializationMetadata.length); }
@Test public void primitives6Metadata() { unsafeClassHeaderSize64BitCompressedOops(new Primitives6()); SerializationMetadata serializationMetadata = extractMetadata(Introspect.fields(Primitives6.class)); assertEquals(OBJECT_HEADER_SIZE, serializationMetadata.start); assertEquals(28, serializationMetadata.length); } |
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } static List<Field> stopAtFirstIneligibleField(List<Field> fields); } | @Test public void staticPrimitivesAreNotEligible() { List<Field> field = fieldsNamed("staticIntField"); assertTrue(stopAtFirstIneligibleField(field).isEmpty()); }
@Test public void staticPrimitiveArraysAreNotEligible() { List<Field> field = fieldsNamed("staticDoubleArray"); assertTrue(stopAtFirstIneligibleField(field).isEmpty()); }
@Test public void staticReferencesAreNotEligible() { List<Field> field = fieldsNamed("staticStringList"); assertTrue(stopAtFirstIneligibleField(field).isEmpty()); }
@Test public void staticReferenceArraysAreNotEligible() { List<Field> field = fieldsNamed("staticObjectArray"); assertTrue(stopAtFirstIneligibleField(field).isEmpty()); }
@Test public void transientPrimitivesAreNotEligible() { List<Field> field = fieldsNamed("transientShort"); assertTrue(stopAtFirstIneligibleField(field).isEmpty()); }
@Test public void transientReferencsAreNotEligible() { List<Field> field = fieldsNamed("transientObject"); assertTrue(stopAtFirstIneligibleField(field).isEmpty()); }
@Test public void includesAllEligibleFields() { List<Field> fields = fieldsNamed("intField", "shortField", "longField", "byteField", "stringList"); List<Field> expectedfields = fields.subList(0, 4); assertEquals(expectedfields, stopAtFirstIneligibleField(fields)); }
@Test public void instancePrimitivesAreEligible() { List<Field> field = fieldsNamed("intField"); assertEquals(field, stopAtFirstIneligibleField(field)); }
@Test public void instancePrimitiveArraysAreNotEligible() { List<Field> field = fieldsNamed("doubleArray"); assertTrue(stopAtFirstIneligibleField(field).isEmpty()); }
@Test public void instanceReferencesAreNotEligible() { List<Field> field = fieldsNamed("stringList"); assertTrue(stopAtFirstIneligibleField(field).isEmpty()); }
@Test public void instanceReferenceArraysAreNotEligible() { List<Field> field = fieldsNamed("objectArray"); assertTrue(stopAtFirstIneligibleField(field).isEmpty()); } |
RawCopier { public static <T> RawCopier<T> copies(Class<T> tClass) { return new RawCopier<T>(tClass); } private RawCopier(Class<T> tClass); static RawCopier<T> copies(Class<T> tClass); int start(); int end(); void toBytes(Object obj, Bytes bytes); void fromBytes(Bytes bytes, Object obj); void copy(T from, T to); } | @Test public void testStartEnd() { RawCopier<A> aRawCopier = RawCopier.copies(A.class); if (aRawCopier.start != 8) assertEquals(12, aRawCopier.start); assertEquals(aRawCopier.start + 3 * 4, aRawCopier.end); RawCopier<B> bRawCopier = RawCopier.copies(B.class); if (aRawCopier.start != 8) assertEquals(16, bRawCopier.start); assertEquals(bRawCopier.start + 4 * 8, bRawCopier.end); } |
ResizeableMappedStore extends AbstractMappedStore { public void resize(long newSize) throws IOException { validateSize(newSize); unmapAndSyncToDisk(); resizeIfNeeded(0L, newSize); this.mmapInfoHolder.setSize(newSize); map(0L); } ResizeableMappedStore(File file, FileChannel.MapMode mode, long size); ResizeableMappedStore(File file, FileChannel.MapMode mode, long size,
ObjectSerializer objectSerializer); void resize(long newSize); } | @Test public void testResizableMappedStore() throws IOException { File file = MappedStoreTest.getStoreFile("resizable-mapped-store.tmp"); final int smallSize = 1024, largeSize = 10 * smallSize; { ResizeableMappedStore ms = new ResizeableMappedStore(file, FileChannel.MapMode.READ_WRITE, smallSize); DirectBytes slice1 = ms.bytes(); for (int i = 0; i < smallSize; ++i) { slice1.writeByte(42); } ms.resize(largeSize); DirectBytes slice2 = ms.bytes(); slice2.skipBytes(smallSize); for (int i = smallSize; i < largeSize; ++i) { slice2.writeByte(24); } ms.close(); } assertEquals(largeSize, file.length()); { ResizeableMappedStore ms = new ResizeableMappedStore(file, FileChannel.MapMode.READ_WRITE, file.length()); DirectBytes slice = ms.bytes(); assertEquals(42, slice.readByte(smallSize - 1)); assertEquals(24, slice.readByte(largeSize - 1)); slice.release(); ms.close(); } } |
VanillaMappedFile implements VanillaMappedResource { @Override public synchronized void close() throws IOException { if (this.fileChannel.isOpen()) { long start = System.nanoTime(); this.fileChannel.close(); this.fileLifecycleListener.onEvent(EventType.CLOSE, this.path, System.nanoTime() - start); } } VanillaMappedFile(final File path, VanillaMappedMode mode); VanillaMappedFile(final File path, VanillaMappedMode mode, long size,
FileLifecycleListener fileLifecycleListener); static VanillaMappedFile readWrite(final File path); static VanillaMappedFile readWrite(final File path, long size); static VanillaMappedFile readOnly(final File path); static VanillaMappedFile readOnly(final File path, long size); static VanillaMappedBytes readWriteBytes(final File path, long size); static VanillaMappedBytes readWriteBytes(final File path, long size, long index); static VanillaMappedBytes readWriteBytes(final File path, long size, long index, FileLifecycleListener fileLifecycleListener); VanillaMappedBytes bytes(long address, long size); VanillaMappedBytes bytes(long address, long size, long index); @Override String path(); @Override long size(); @Override synchronized void close(); } | @Test public void testMappedCache3() throws IOException { VanillaMappedCache<Integer> cache = new VanillaMappedCache(32, false); VanillaMappedBytes buffer = null; File file = null; for (int j = 0; j < 5; j++) { long start = System.nanoTime(); int maxRuns = 10000, runs; for (runs = 0; runs < maxRuns; runs++) { file = newTempraryFile("vmc-3-v" + runs, false); buffer = cache.put(runs, file, 256, runs); buffer.writeLong(0, 0x12345678); assertEquals(0x12345678L, buffer.readLong(0)); assertEquals(runs, buffer.index()); buffer.release(); buffer.close(); assertEquals(0, buffer.refCount()); assertTrue(file.delete()); if (System.nanoTime() - start > 1e9) break; } long time = System.nanoTime() - start; System.out.printf("The average time was %,d us%n", time / runs / 1000); } cache.close(); }
@Test public void testMappedCache4() throws IOException { VanillaMappedCache<Integer> cache = new VanillaMappedCache(10000, true); VanillaMappedBytes buffer = cache.put(1, newTempraryFile("vmc-4"), 256, 1); buffer.reserve(); assertEquals(2, buffer.refCount()); buffer.release(); assertEquals(1, buffer.refCount()); cache.close(); assertEquals(0, buffer.refCount()); } |
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); } | @Test public void testGenerateJavaCode() { DataValueGenerator dvg = new DataValueGenerator(); JavaBeanInterface jbi = dvg.heapInstance(JavaBeanInterface.class); jbi.setByte((byte) 1); jbi.setChar('2'); jbi.setShort((short) 3); jbi.setInt(4); jbi.setFloat(5); jbi.setLong(6); jbi.setDouble(7); jbi.setFlag(true); assertEquals(1, jbi.getByte()); assertEquals('2', jbi.getChar()); assertEquals(3, jbi.getShort()); assertEquals(4, jbi.getInt()); assertEquals(5.0, jbi.getFloat(), 0); assertEquals(6, jbi.getLong()); assertEquals(7.0, jbi.getDouble(), 0.0); assertTrue(jbi.getFlag()); }
@Test public void testGenerateJavaCode2() { DataValueGenerator dvg = new DataValueGenerator(); MinimalInterface mi = dvg.heapInstance(MinimalInterface.class); mi.byte$((byte) 1); mi.char$('2'); mi.short$((short) 3); mi.int$(4); mi.float$(5); mi.long$(6); mi.double$(7); mi.flag(true); assertEquals(1, mi.byte$()); assertEquals('2', mi.char$()); assertEquals(3, mi.short$()); assertEquals(4, mi.int$()); assertEquals(5.0, mi.float$(), 0); assertEquals(6, mi.long$()); assertEquals(7.0, mi.double$(), 0.0); assertTrue(mi.flag()); Bytes bbb = ByteBufferBytes.wrap(ByteBuffer.allocate(64)); mi.writeMarshallable(bbb); System.out.println("size: " + bbb.position()); MinimalInterface mi2 = dvg.heapInstance(MinimalInterface.class); bbb.position(0); mi2.readMarshallable(bbb); assertEquals(1, mi2.byte$()); assertEquals('2', mi2.char$()); assertEquals(3, mi2.short$()); assertEquals(4, mi2.int$()); assertEquals(5.0, mi2.float$(), 0); assertEquals(6, mi2.long$()); assertEquals(7.0, mi2.double$(), 0.0); assertTrue(mi2.flag()); }
@Test public void testGenerateNativeWithGetUsingHeapInstance() { DataValueGenerator dvg = new DataValueGenerator(); JavaBeanInterfaceGetUsingHeap si = dvg.heapInstance(JavaBeanInterfaceGetUsingHeap.class); si.setString("G'day"); assertEquals("G'day", si.getUsingString(new StringBuilder()).toString()); }
@Test public void testGetUsingStringFieldsWithStringBuilderHeapInstance() { DataValueGenerator dvg = new DataValueGenerator(); GetUsingStringInterface si = dvg.heapInstance(GetUsingStringInterface.class); si.setSomeStringField("Hello world"); si.setAnotherStringField("Hello world 2"); assertEquals("Hello world", si.getSomeStringField()); { StringBuilder builder = new StringBuilder(); si.getUsingSomeStringField(builder); assertEquals("Hello world", builder.toString()); } { StringBuilder builder = new StringBuilder(); si.getUsingAnotherStringField(builder); assertEquals("Hello world 2", builder.toString()); } }
@Test public void testGenerateInterfaceWithEnumOnHeap() { DataValueGenerator dvg = new DataValueGenerator(); JavaBeanInterfaceGetMyEnum jbie = dvg.heapInstance(JavaBeanInterfaceGetMyEnum.class); jbie.setMyEnum(MyEnum.B); }
@Test public void testGenerateInterfaceWithDateOnHeap() { DataValueGenerator dvg = new DataValueGenerator(); JavaBeanInterfaceGetDate jbid = dvg.heapInstance(JavaBeanInterfaceGetDate.class); jbid.setDate(new Date()); } |
DataValueGenerator { public String generateNativeObject(Class<?> tClass) { return generateNativeObject(DataValueModels.acquireModel(tClass)); } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); } | @Test public void testGenerateNativeWithGetUsing() throws ClassNotFoundException, IllegalAccessException, InstantiationException { String actual = new DataValueGenerator().generateNativeObject(JavaBeanInterfaceGetUsing.class); System.out.println(actual); CachedCompiler cc = new CachedCompiler(null, null); Class aClass = cc.loadFromJava(JavaBeanInterfaceGetUsing.class.getName() + "$$Native", actual); JavaBeanInterfaceGetUsing jbi = (JavaBeanInterfaceGetUsing) aClass.asSubclass(JavaBeanInterfaceGetUsing.class).newInstance(); Bytes bytes = ByteBufferBytes.wrap(ByteBuffer.allocate(64)); ((Byteable) jbi).bytes(bytes, 0L); jbi.setString("G'day"); assertEquals("G'day", jbi.getUsingString(new StringBuilder()).toString()); }
@Test public void testGenerateNativeWithHasArrays() throws ClassNotFoundException, IllegalAccessException, InstantiationException { String actual = new DataValueGenerator().generateNativeObject(HasArraysInterface.class); System.out.println(actual); CachedCompiler cc = new CachedCompiler(null, null); Class aClass = cc.loadFromJava(HasArraysInterface.class.getName() + "$$Native", actual); HasArraysInterface hai = (HasArraysInterface) aClass.asSubclass(HasArraysInterface.class).newInstance(); Bytes bytes = ByteBufferBytes.wrap(ByteBuffer.allocate(152)); ((Byteable) hai).bytes(bytes, 0L); hai.setStringAt(0, "G'day"); assertEquals("G'day", hai.getStringAt(0)); } |
DataValueGenerator { public <T> T nativeInstance(Class<T> tClass) { try { return (T) acquireNativeClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); } | @Test public void testGenerateInterfaceWithEnumNativeInstance() { DataValueGenerator dvg = new DataValueGenerator(); JavaBeanInterfaceGetMyEnum jbie = dvg.nativeInstance(JavaBeanInterfaceGetMyEnum.class); Bytes bytes = ByteBufferBytes.wrap(ByteBuffer.allocate(64)); ((Byteable) jbie).bytes(bytes, 0L); jbie.setMyEnum(MyEnum.C); }
@Test public void testGenerateInterfaceWithDateNativeInstace() { DataValueGenerator dvg = new DataValueGenerator(); JavaBeanInterfaceGetDate jbid = dvg.nativeInstance(JavaBeanInterfaceGetDate.class); Bytes bytes = ByteBufferBytes.wrap(ByteBuffer.allocate(64)); ((Byteable) jbid).bytes(bytes, 0L); jbid.setDate(new Date()); assertEquals(new Date(), jbid.getDate()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.