Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: DiscoveryTreeNode extends VersionedCache { @SuppressWarnings("unchecked") public <T> T attribute(String key) { return (T) attributes.get(key); } boolean childrenInited(); DiscoveryTreeNode childrenInited(boolean childrenInited); int level(); DiscoveryTreeNode level(int level); @SuppressWarnings("unchecked") T attribute(String key); DiscoveryTreeNode attribute(String key, Object value); Map<String, DiscoveryTreeNode> children(); DiscoveryTreeNode children(Map<String, DiscoveryTreeNode> children); DiscoveryTreeNode child(String childName); DiscoveryTreeNode child(String childName, DiscoveryTreeNode child); DiscoveryTreeNode fromCache(VersionedCache other); }### Answer: @Test public void attribute() { node.attribute("k1", "v1"); Assert.assertEquals("v1", node.attribute("k1")); }
### Question: DiscoveryTreeNode extends VersionedCache { public Map<String, DiscoveryTreeNode> children() { return children; } boolean childrenInited(); DiscoveryTreeNode childrenInited(boolean childrenInited); int level(); DiscoveryTreeNode level(int level); @SuppressWarnings("unchecked") T attribute(String key); DiscoveryTreeNode attribute(String key, Object value); Map<String, DiscoveryTreeNode> children(); DiscoveryTreeNode children(Map<String, DiscoveryTreeNode> children); DiscoveryTreeNode child(String childName); DiscoveryTreeNode child(String childName, DiscoveryTreeNode child); DiscoveryTreeNode fromCache(VersionedCache other); }### Answer: @Test public void children() { Map<String, DiscoveryTreeNode> children = new HashMap<>(); node.children(children); Assert.assertSame(children, node.children()); }
### Question: DiscoveryTreeNode extends VersionedCache { public DiscoveryTreeNode child(String childName) { return children.get(childName); } boolean childrenInited(); DiscoveryTreeNode childrenInited(boolean childrenInited); int level(); DiscoveryTreeNode level(int level); @SuppressWarnings("unchecked") T attribute(String key); DiscoveryTreeNode attribute(String key, Object value); Map<String, DiscoveryTreeNode> children(); DiscoveryTreeNode children(Map<String, DiscoveryTreeNode> children); DiscoveryTreeNode child(String childName); DiscoveryTreeNode child(String childName, DiscoveryTreeNode child); DiscoveryTreeNode fromCache(VersionedCache other); }### Answer: @Test public void child() { DiscoveryTreeNode child = new DiscoveryTreeNode().name("child"); node.child(child.name(), child); Assert.assertSame(child, node.child(child.name())); }
### Question: DiscoveryTreeNode extends VersionedCache { public DiscoveryTreeNode fromCache(VersionedCache other) { this.cacheVersion = other.cacheVersion(); this.name = other.name(); this.data(other.data()); return this; } boolean childrenInited(); DiscoveryTreeNode childrenInited(boolean childrenInited); int level(); DiscoveryTreeNode level(int level); @SuppressWarnings("unchecked") T attribute(String key); DiscoveryTreeNode attribute(String key, Object value); Map<String, DiscoveryTreeNode> children(); DiscoveryTreeNode children(Map<String, DiscoveryTreeNode> children); DiscoveryTreeNode child(String childName); DiscoveryTreeNode child(String childName, DiscoveryTreeNode child); DiscoveryTreeNode fromCache(VersionedCache other); }### Answer: @Test public void fromCache() { Object data = new Object(); VersionedCache other = new VersionedCache().cacheVersion(1).name("cache").data(data); node.fromCache(other); Assert.assertEquals(1, node.cacheVersion()); Assert.assertEquals("cache", node.name()); Assert.assertSame(data, node.data()); }
### Question: AbstractPropertiesLoader { public Map<String, String> loadProperties(Configuration configuration) { Map<String, String> propertiesMap = new HashMap<>(); loadPropertiesFromConfigMap(configuration, propertiesMap); loadPropertiesFromExtendedClass(configuration, propertiesMap); return propertiesMap; } Map<String, String> loadProperties(Configuration configuration); }### Answer: @Test public void testExtendedClassCompatible() { Configuration configuration = new DynamicConfiguration(); configuration.setProperty(BootStrapProperties.CONFIG_SERVICE_EXTENDED_CLASS, "invalidClass"); AbstractPropertiesLoader loader = MicroservicePropertiesLoader.INSTANCE; try { loader.loadProperties(configuration); Assert.fail("Must throw exception"); } catch (Error e) { Assert.assertEquals(ClassNotFoundException.class, e.getCause().getClass()); Assert.assertEquals("invalidClass", e.getCause().getMessage()); } }
### Question: VersionRuleRangeParser implements VersionRuleParser { @Override public VersionRule parse(String strVersionRule) { int pos = strVersionRule.indexOf('-'); if (pos <= 0 \|\| pos == strVersionRule.length() - 1) { return null; } Version from = new Version(strVersionRule.substring(0, pos)); Version to = new Version(strVersionRule.substring(pos + 1)); return new RangeVersionRule(from.getVersion() + "-" + to.getVersion(), from, to); } @Override VersionRule parse(String strVersionRule); }### Answer: @Test public void parseInvalid() { Assert.assertNull(parser.parse("")); Assert.assertNull(parser.parse("-")); Assert.assertNull(parser.parse("1-")); }
### Question: VersionRule { public boolean isAccept(Version version) { return isMatch(version, null); } VersionRule(String versionRule); String getVersionRule(); boolean isAccept(Version version); abstract boolean isMatch(Version version, Version latestVersion); @Override String toString(); }### Answer: @Test public void isAccept() { Assert.assertTrue(versionRule.isAccept(null)); }
### Question: VersionRule { public String getVersionRule() { return versionRule; } VersionRule(String versionRule); String getVersionRule(); boolean isAccept(Version version); abstract boolean isMatch(Version version, Version latestVersion); @Override String toString(); }### Answer: @Test public void getVersionRule() { Assert.assertEquals("abc", versionRule.getVersionRule()); }
### Question: VersionRuleFixedParser implements VersionRuleParser { @Override public VersionRule parse(String strVersionRule) { Version version = new Version(strVersionRule); return new FixedVersionRule(version.getVersion(), version); } @Override VersionRule parse(String strVersionRule); }### Answer: @Test public void parseNormal() { versionRule = parser.parse("1"); Assert.assertEquals("1.0.0.0", versionRule.getVersionRule()); } @Test public void isMatch() { versionRule = parser.parse("1"); Assert.assertTrue(versionRule.isMatch(VersionConst.v1, null)); Assert.assertFalse(versionRule.isMatch(VersionConst.v2, null)); }
### Question: VersionUtils { public static Version getOrCreate(String strVersion) { Objects.requireNonNull(strVersion); return versionCache.computeIfAbsent(strVersion, Version::new); } static Version getOrCreate(String strVersion); }### Answer: @Test public void getOrCreate() { Version v = VersionUtils.getOrCreate("1.0.0"); Assert.assertEquals("1.0.0.0", v.getVersion()); Assert.assertSame(v, VersionUtils.getOrCreate("1.0.0")); }
### Question: VersionRuleUtils { public static VersionRule getOrCreate(String strVersionRule) { Objects.requireNonNull(strVersionRule); return versionRuleCache.computeIfAbsent(strVersionRule, VersionRuleUtils::create); } static VersionRule getOrCreate(String strVersionRule); static VersionRule create(String strVersionRule); }### Answer: @Test public void fixed() { VersionRule versionRule = VersionRuleUtils.getOrCreate("1"); Assert.assertThat(versionRule, Matchers.instanceOf(FixedVersionRule.class)); Assert.assertSame(versionRule, VersionRuleUtils.getOrCreate("1")); } @Test public void latest() { VersionRule versionRule = VersionRuleUtils.getOrCreate(DefinitionConst.VERSION_RULE_LATEST); Assert.assertThat(versionRule, Matchers.instanceOf(LatestVersionRule.class)); Assert.assertSame(versionRule, VersionRuleUtils.getOrCreate(DefinitionConst.VERSION_RULE_LATEST)); } @Test public void range() { VersionRule versionRule = VersionRuleUtils.getOrCreate("1-2"); Assert.assertThat(versionRule, Matchers.instanceOf(RangeVersionRule.class)); Assert.assertSame(versionRule, VersionRuleUtils.getOrCreate("1-2")); } @Test public void startFrom() { VersionRule versionRule = VersionRuleUtils.getOrCreate("1+"); Assert.assertThat(versionRule, Matchers.instanceOf(StartFromVersionRule.class)); Assert.assertSame(versionRule, VersionRuleUtils.getOrCreate("1+")); } @Test public void invalid() { expectedException.expect(IllegalStateException.class); expectedException.expectMessage(Matchers.is("Invalid major \"\", version \"\".")); VersionRuleUtils.getOrCreate(""); }
### Question: Version implements Comparable<Version> { @Override public String toString() { return version; } Version(String version); Version(short major, short minor, short patch, short build); short getMajor(); short getMinor(); short getPatch(); short getBuild(); String getVersion(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); @Override int compareTo(Version other); }### Answer: @Test public void testToString() { version = new Version(s1, s1, s1, s1); Assert.assertEquals("1.1.1.1", version.toString()); }
### Question: Version implements Comparable<Version> { @Override public int hashCode() { return version.hashCode(); } Version(String version); Version(short major, short minor, short patch, short build); short getMajor(); short getMinor(); short getPatch(); short getBuild(); String getVersion(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); @Override int compareTo(Version other); }### Answer: @Test public void testHashCode() { version = new Version(s1, s1, s1, s1); Assert.assertEquals(version.getVersion().hashCode(), version.hashCode()); }
### Question: Version implements Comparable<Version> { @Override public boolean equals(Object other) { if (other == this) { return true; } if (!(other instanceof Version)) { return false; } return numberVersion == ((Version) other).numberVersion; } Version(String version); Version(short major, short minor, short patch, short build); short getMajor(); short getMinor(); short getPatch(); short getBuild(); String getVersion(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); @Override int compareTo(Version other); }### Answer: @Test public void testEquals() { version = new Version(s1, s1, s1, s1); Assert.assertTrue(version.equals(version)); Assert.assertTrue(version.equals(new Version(s1, s1, s1, s1))); Assert.assertFalse(version.equals(null)); }
### Question: Version implements Comparable<Version> { @Override public int compareTo(Version other) { return Long.compare(numberVersion, other.numberVersion); } Version(String version); Version(short major, short minor, short patch, short build); short getMajor(); short getMinor(); short getPatch(); short getBuild(); String getVersion(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); @Override int compareTo(Version other); }### Answer: @Test public void compareTo() { version = new Version(s1, s1, s1, s1); Assert.assertEquals(0, version.compareTo(version)); Assert.assertEquals(0, version.compareTo(new Version(s1, s1, s1, s1))); Assert.assertEquals(-1, version.compareTo(new Version(s1, s1, s2, s1))); Assert.assertEquals(-1, version.compareTo(new Version(s1, s2, s1, s1))); Assert.assertEquals(-1, version.compareTo(new Version(s2, s1, s1, s1))); Assert.assertEquals(1, version.compareTo(new Version((short) 0, Short.MAX_VALUE, Short.MAX_VALUE, Short.MAX_VALUE))); }
### Question: VersionRuleStartFromParser implements VersionRuleParser { @Override public VersionRule parse(String strVersionRule) { int pos = strVersionRule.indexOf('+'); if (pos <= 0 \|\| pos != strVersionRule.length() - 1) { return null; } Version from = new Version(strVersionRule.substring(0, pos)); return new StartFromVersionRule(from.getVersion() + "+", from); } @Override VersionRule parse(String strVersionRule); }### Answer: @Test public void parseInvalid() { Assert.assertNull(parser.parse("")); Assert.assertNull(parser.parse("+")); Assert.assertNull(parser.parse("1+1")); }
### Question: VertxRestAccessLogPatternParser implements AccessLogPatternParser<RoutingContext> { public static int comparePlaceholderString(String s1, String s2) { int result = s1.compareTo(s2); if (0 == result) { return result; } return result < 0 ? (s2.startsWith(s1) ? -result : result) : (s1.startsWith(s2) ? -result : result); } VertxRestAccessLogPatternParser(); static int comparePlaceholderString(String s1, String s2); static void sortAccessLogItemMeta(List<VertxRestAccessLogItemMeta> accessLogItemMetaList); @Override List<AccessLogItem<RoutingContext>> parsePattern(String rawPattern); static final Comparator<VertxRestAccessLogItemMeta> accessLogItemMetaComparator; }### Answer: @Test public void testComparePlaceholderString() { Assert.assertTrue( VertxRestAccessLogPatternParser.comparePlaceholderString("abc", "bbc") < 0 ); Assert.assertTrue( VertxRestAccessLogPatternParser.comparePlaceholderString("abc", "ab") < 0 ); Assert.assertEquals(0, VertxRestAccessLogPatternParser.comparePlaceholderString("abc", "abc")); Assert.assertTrue( VertxRestAccessLogPatternParser.comparePlaceholderString("bbc", "abc") > 0 ); Assert.assertTrue( VertxRestAccessLogPatternParser.comparePlaceholderString("ab", "abc") > 0 ); }
### Question: AccessLogGenerator { public String generateServerLog(ServerAccessLogEvent accessLogEvent) { StringBuilder log = new StringBuilder(128); for (AccessLogItem<RoutingContext> accessLogItem : getAccessLogItems()) { accessLogItem.appendServerFormattedItem(accessLogEvent, log); } return log.toString(); } @SuppressWarnings("unchecked") AccessLogGenerator(String rawPattern); String generateServerLog(ServerAccessLogEvent accessLogEvent); String generateClientLog(InvocationFinishEvent finishEvent); }### Answer: @Test public void testServerLog() { RoutingContext context = Mockito.mock(RoutingContext.class); HttpServerRequest request = Mockito.mock(HttpServerRequest.class); long startMillisecond = 1416863450581L; ServerAccessLogEvent serverAccessLogEvent = new ServerAccessLogEvent(); serverAccessLogEvent.setMilliStartTime(startMillisecond).setRoutingContext(context); SimpleDateFormat simpleDateFormat = new SimpleDateFormat(ConfigurableDatetimeAccessItem.DEFAULT_DATETIME_PATTERN, ConfigurableDatetimeAccessItem.DEFAULT_LOCALE); simpleDateFormat.setTimeZone(TimeZone.getDefault()); when(context.request()).thenReturn(request); when(request.method()).thenReturn(HttpMethod.DELETE); String log = LOG_GENERATOR.generateServerLog(serverAccessLogEvent); Assert.assertEquals("DELETE" + " - " + simpleDateFormat.format(startMillisecond), log); }
### Question: AccessLogGenerator { public String generateClientLog(InvocationFinishEvent finishEvent) { StringBuilder log = new StringBuilder(128); for (AccessLogItem<RoutingContext> accessLogItem : getAccessLogItems()) { accessLogItem.appendClientFormattedItem(finishEvent, log); } return log.toString(); } @SuppressWarnings("unchecked") AccessLogGenerator(String rawPattern); String generateServerLog(ServerAccessLogEvent accessLogEvent); String generateClientLog(InvocationFinishEvent finishEvent); }### Answer: @Test public void testClientLog() { Invocation invocation = Mockito.mock(Invocation.class); InvocationStageTrace stageTrace = Mockito.mock(InvocationStageTrace.class); OperationMeta operationMeta = Mockito.mock(OperationMeta.class); long startMillisecond = 1416863450581L; when(stageTrace.getStartSend()).thenReturn(0L); when(stageTrace.getStart()).thenReturn(0L); when(stageTrace.getFinish()).thenReturn(0L); when(stageTrace.getStartCurrentTime()).thenReturn(startMillisecond); when(invocation.getOperationMeta()).thenReturn(operationMeta); when(invocation.getInvocationStageTrace()).thenReturn(stageTrace); InvocationFinishEvent finishEvent = new InvocationFinishEvent(invocation, null); SimpleDateFormat simpleDateFormat = new SimpleDateFormat(ConfigurableDatetimeAccessItem.DEFAULT_DATETIME_PATTERN, ConfigurableDatetimeAccessItem.DEFAULT_LOCALE); simpleDateFormat.setTimeZone(TimeZone.getDefault()); when(operationMeta.getHttpMethod()).thenReturn(HttpMethod.DELETE.toString()); String log = LOG_GENERATOR.generateClientLog(finishEvent); Assert.assertEquals("DELETE" + " - " + simpleDateFormat.format(startMillisecond), log); }
### Question: SwaggerToProtoGenerator { public Proto convert() { convertDefinitions(); convertOperations(); for (; ; ) { List<Runnable> oldPending = pending; pending = new ArrayList<>(); for (Runnable runnable : oldPending) { runnable.run(); } if (pending.isEmpty()) { break; } } return createProto(); } SwaggerToProtoGenerator(String protoPackage, Swagger swagger); Proto convert(); static String escapePackageName(String name); static String escapeMessageName(String name); static boolean isValidEnum(String name); }### Answer: @Test public void convert() throws IOException { URL url = TestSwaggerToProtoGenerator.class.getClassLoader().getResource("ProtoSchema.proto"); String protoContent = IOUtils.toString(url, "UTF-8"); int idx = protoContent.indexOf("syntax = "); protoContent = protoContent.substring(idx); SpringmvcSwaggerGenerator swaggerGenerator = new SpringmvcSwaggerGenerator(ProtoSchema.class); Swagger swagger = swaggerGenerator.generate(); SwaggerToProtoGenerator generator = new SwaggerToProtoGenerator("a.b", swagger); Proto proto = generator.convert(); Assert.assertEquals(protoContent.replaceAll("\r\n", "\n"), new ProtoToStringGenerator(proto).protoToString().replaceAll("\r\n", "\n")); }
### Question: ProtoToStringGenerator { public String protoToString() { StringBuilder sb = new StringBuilder(); appendLine(sb, "syntax = \"%s\";", proto.getSyntax()); for (Import importValue : proto.getImports()) { appendLine(sb, "import \"%s\";", importValue.getValue()); } appendLine(sb, "package %s;\n", proto.getPackage().getValue()); for (Message message : proto.getMessages()) { messageToString(message, sb); } for (Enum enumValue : proto.getEnums()) { enumToString(enumValue, sb); } for (Service service : proto.getServices()) { serviceToString(service, sb); } return sb.toString(); } ProtoToStringGenerator(Proto proto); String protoToString(); }### Answer: @Test public void protoToString() { ProtoParser protoParser = new ProtoParser(); Proto proto = protoParser.parseFromContent(content); String newContent = new ProtoToStringGenerator(proto).protoToString(); Assert.assertEquals(content, newContent); }
### Question: RestCodec { public static void argsToRest(Map<String, Object> args, RestOperationMeta restOperation, RestClientRequest clientRequest) throws Exception { int paramSize = restOperation.getParamList().size(); if (paramSize == 0) { return; } for (int idx = 0; idx < paramSize; idx++) { RestParam param = restOperation.getParamList().get(idx); param.getParamProcessor().setValue(clientRequest, args.get(param.getParamName())); } } private RestCodec(); static void argsToRest(Map<String, Object> args, RestOperationMeta restOperation, RestClientRequest clientRequest); static Map<String, Object> restToArgs(HttpServletRequest request, RestOperationMeta restOperation); }### Answer: @Test public void testArgsToRest() { try { Map<String, Object> args = new HashMap<>(); args.put("header", "abc"); RestCodec.argsToRest(args, restOperation, clientRequest); Assert.assertEquals("abc", header.get("header")); } catch (Exception e) { e.printStackTrace(); Assert.assertTrue(false); } }
### Question: ProduceJsonProcessor implements ProduceProcessor { @Override public void setSerializationView(Class<?> serializationView) { if (serializationView == null) { return; } this.serializationView = serializationView; } @Override String getSerializationView(); @Override void setSerializationView(Class<?> serializationView); @Override String getName(); @Override void doEncodeResponse(OutputStream output, Object result); @Override Object doDecodeResponse(InputStream input, JavaType type); @Override int getOrder(); }### Answer: @Test public void testSetSerializationView() { Assert.assertEquals(DEFAULT_SERIAL_CLASS, pp.getSerializationView()); pp.setSerializationView(null); Assert.assertEquals(DEFAULT_SERIAL_CLASS, pp.getSerializationView()); pp.setSerializationView(Object.class); Assert.assertEquals(Object.class.getCanonicalName(), pp.getSerializationView()); }
### Question: PathProcessorCreator implements ParamValueProcessorCreator { @Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { JavaType targetType = genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType); return new PathProcessor(parameter.getName(), targetType, ((PathParameter) parameter).getDefaultValue(), true); } PathProcessorCreator(); @Override ParamValueProcessor create(Parameter parameter, Type genericParamType); static final String PARAMTYPE; }### Answer: @Test public void testCreate() { ParamValueProcessorCreator creator = ParamValueProcessorCreatorManager.INSTANCE.findValue(PathProcessorCreator.PARAMTYPE); Parameter parameter = new PathParameter(); parameter.setName("path"); ParamValueProcessor processor = creator.create(parameter, String.class); Assert.assertEquals(PathProcessor.class, processor.getClass()); }
### Question: FormProcessorCreator implements ParamValueProcessorCreator { @Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { JavaType targetType = genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType); if (isPart(parameter)) { return new PartProcessor((FormParameter) parameter, genericParamType); } return new FormProcessor((FormParameter) parameter, targetType); } FormProcessorCreator(); @Override ParamValueProcessor create(Parameter parameter, Type genericParamType); static final String PARAMTYPE; }### Answer: @Test public void testCreate() { ParamValueProcessorCreator creator = ParamValueProcessorCreatorManager.INSTANCE.findValue(FormProcessorCreator.PARAMTYPE); FormParameter p = new FormParameter(); p.setName("p1"); ParamValueProcessor processor = creator.create(p, String.class); Assert.assertEquals(FormProcessor.class, processor.getClass()); }
### Question: RestClientRequestImpl implements RestClientRequest { protected void doEndWithUpload() { request.setChunked(true); String boundary = "boundary" + UUID.randomUUID().toString(); putHeader(CONTENT_TYPE, MULTIPART_FORM_DATA + "; charset=UTF-8; boundary=" + boundary); genBodyForm(boundary); attachFiles(boundary); } RestClientRequestImpl(HttpClientRequest request, Context context, AsyncResponse asyncResp); RestClientRequestImpl(HttpClientRequest request, Context context, AsyncResponse asyncResp, Handler<Throwable> throwableHandler); @Override void write(Buffer bodyBuffer); @Override Buffer getBodyBuffer(); @Override @SuppressWarnings("unchecked") void attach(String name, Object partOrList); @Override void end(); Context getContext(); HttpClientRequest getRequest(); Map<String, String> getCookieMap(); Map<String, Object> getFormMap(); @Override void addCookie(String name, String value); @Override void addForm(String name, Object value); @Override void putHeader(String name, String value); @Override MultiMap getHeaders(); }### Answer: @Test public void doEndWithUpload() { Map<String, String> headers = new HashMap<>(); new MockUp<HttpClientRequest>(request) { @Mock HttpClientRequest putHeader(String name, String value) { headers.put(name, value); return request; } }; UUID uuid = new UUID(0, 0); new Expectations(UUID.class) { { UUID.randomUUID(); result = uuid; } }; RestClientRequestImpl restClientRequest = new RestClientRequestImpl(request, null, null); restClientRequest.doEndWithUpload(); Assert.assertEquals("multipart/form-data; charset=UTF-8; boundary=boundary00000000-0000-0000-0000-000000000000", headers.get(HttpHeaders.CONTENT_TYPE.toString())); }
### Question: BodyProcessorCreator implements ParamValueProcessorCreator { @Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { Model model = ((BodyParameter) parameter).getSchema(); JavaType swaggerType = null; if (model instanceof ModelImpl) { swaggerType = ConverterMgr.findJavaType(((ModelImpl) model).getType(), ((ModelImpl) model).getFormat()); } boolean isString = swaggerType != null && swaggerType.getRawClass().equals(String.class); JavaType targetType = genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType); boolean rawJson = SwaggerUtils.isRawJsonType(parameter); if (rawJson) { return new RawJsonBodyProcessor(targetType, (String) parameter.getVendorExtensions() .get(SwaggerConst.EXT_JSON_VIEW), isString, parameter.getRequired()); } return new BodyProcessor(targetType, (String) parameter.getVendorExtensions() .get(SwaggerConst.EXT_JSON_VIEW), isString, parameter.getRequired()); } BodyProcessorCreator(); @Override ParamValueProcessor create(Parameter parameter, Type genericParamType); static final String PARAMTYPE; }### Answer: @Test public void testCreateNormal() { ParamValueProcessorCreator creator = ParamValueProcessorCreatorManager.INSTANCE.findValue(BodyProcessorCreator.PARAMTYPE); BodyParameter param = new BodyParameter(); ParamValueProcessor processor = creator.create(param, String.class); Assert.assertEquals(BodyProcessor.class, processor.getClass()); } @Test public void testCreateRawJson() { ParamValueProcessorCreator creator = ParamValueProcessorCreatorManager.INSTANCE.findValue(BodyProcessorCreator.PARAMTYPE); BodyParameter param = new BodyParameter(); param.setVendorExtension(SwaggerConst.EXT_RAW_JSON_TYPE, true); ParamValueProcessor processor = creator.create(param, String.class); Assert.assertEquals(RawJsonBodyProcessor.class, processor.getClass()); }
### Question: HeaderProcessorCreator implements ParamValueProcessorCreator { @Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { JavaType targetType = genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType); return new HeaderProcessor((HeaderParameter) parameter, targetType); } HeaderProcessorCreator(); @Override ParamValueProcessor create(Parameter parameter, Type genericParamType); static final String PARAMTYPE; }### Answer: @Test public void testCreate() { ParamValueProcessorCreator creator = ParamValueProcessorCreatorManager.INSTANCE.findValue(HeaderProcessorCreator.PARAMTYPE); HeaderParameter hp = new HeaderParameter(); hp.setName("h1"); ParamValueProcessor processor = creator.create(hp, String.class); Assert.assertEquals(HeaderProcessor.class, processor.getClass()); }
### Question: CookieProcessorCreator implements ParamValueProcessorCreator { @Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { JavaType targetType = genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType); return new CookieProcessor(parameter.getName(), targetType, ((CookieParameter) parameter).getDefaultValue(), parameter.getRequired()); } CookieProcessorCreator(); @Override ParamValueProcessor create(Parameter parameter, Type genericParamType); static final String PARAMTYPE; }### Answer: @Test public void testCreate() { ParamValueProcessorCreator creator = ParamValueProcessorCreatorManager.INSTANCE.findValue(CookieProcessorCreator.PARAMTYPE); CookieParameter p = new CookieParameter(); p.setName("p1"); ParamValueProcessor processor = creator.create(p, String.class); Assert.assertEquals(CookieProcessor.class, processor.getClass()); }
### Question: HttpServerFilterBeforeSendResponseExecutor { public CompletableFuture<Void> run() { doRun(); return future; } HttpServerFilterBeforeSendResponseExecutor(List<HttpServerFilter> httpServerFilters, Invocation invocation, HttpServletResponseEx responseEx); CompletableFuture<Void> run(); }### Answer: @Test public void runSucc() throws InterruptedException, ExecutionException { CompletableFuture<Void> result = executor.run(); Assert.assertNull(result.get()); } @Test public void runFail() throws InterruptedException, ExecutionException { httpServerFilters.add(new HttpServerFilterBaseForTest() { @Override public CompletableFuture<Void> beforeSendResponseAsync(Invocation invocation, HttpServletResponseEx responseEx) { throw new RuntimeExceptionWithoutStackTrace(); } }); CompletableFuture<Void> result = executor.run(); expectedException.expect(ExecutionException.class); expectedException.expectCause(Matchers.instanceOf(RuntimeExceptionWithoutStackTrace.class)); result.get(); }
### Question: RestServerCodecFilter implements Filter { @Override public CompletableFuture<Response> onFilter(Invocation invocation, FilterNode nextNode) { return CompletableFuture.completedFuture(invocation) .thenCompose(this::decodeRequest) .thenCompose(nextNode::onFilter) .exceptionally(exception -> exceptionToResponse(invocation, exception, INTERNAL_SERVER_ERROR)) .thenCompose(response -> encodeResponse(invocation, response)); } @Override CompletableFuture<Response> onFilter(Invocation invocation, FilterNode nextNode); @SuppressWarnings("deprecation") static CompletableFuture<Response> encodeResponse(Response response, boolean download, ProduceProcessor produceProcessor, HttpServletResponseEx responseEx); static boolean isDownloadFileResponseType(Invocation invocation, Response response); static void copyHeadersToHttpResponse(Map<String, List<Object>> headerMap, HttpServletResponseEx responseEx); }### Answer: @Test public void should_not_invoke_filter_when_decode_request_failed(@Mocked FilterNode nextNode) { mockDecodeRequestFail(); codecFilter.onFilter(invocation, nextNode); new Verifications() { { nextNode.onFilter(invocation); times = 0; } }; } @Test public void should_convert_exception_to_response_when_decode_request_failed() throws ExecutionException, InterruptedException { mockDecodeRequestFail(); new Expectations(invocation) { { invocation.findResponseType(anyInt); result = TypeFactory.defaultInstance().constructType(String.class); } }; Response response = codecFilter.onFilter(invocation, nextNode).get(); assertThat(response.getStatus()).isEqualTo(INTERNAL_SERVER_ERROR); assertThat(Json.encode(response.getResult())) .isEqualTo("{\"code\":\"SCB.50000000\",\"message\":\"encode request failed\"}"); }
### Question: AbstractRestInvocation { public void setHttpServerFilters(List<HttpServerFilter> httpServerFilters) { this.httpServerFilters = httpServerFilters; } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; }### Answer: @Test public void setHttpServerFilters(@Mocked List<HttpServerFilter> httpServerFilters) { restInvocation.setHttpServerFilters(httpServerFilters); Assert.assertSame(httpServerFilters, restInvocation.httpServerFilters); }
### Question: AbstractRestInvocation { protected void initProduceProcessor() { produceProcessor = restOperationMeta.ensureFindProduceProcessor(requestEx); if (produceProcessor == null) { LOGGER.error("Accept {} is not supported, operation={}.", requestEx.getHeader(HttpHeaders.ACCEPT), restOperationMeta.getOperationMeta().getMicroserviceQualifiedName()); String msg = String.format("Accept %s is not supported", requestEx.getHeader(HttpHeaders.ACCEPT)); throw new InvocationException(Status.NOT_ACCEPTABLE, msg); } } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; }### Answer: @Test public void initProduceProcessorNull() { new Expectations() { { requestEx.getHeader(HttpHeaders.ACCEPT); result = "notExistType"; } }; restInvocation = new AbstractRestInvocationForTest() { @Override public void sendFailResponse(Throwable throwable) { } }; initRestInvocation(); expectedException.expect(InvocationException.class); expectedException .expectMessage( "InvocationException: code=406;msg=CommonExceptionData [message=Accept notExistType is not supported]"); restInvocation.initProduceProcessor(); } @Test public void initProduceProcessorNormal() { new Expectations() { { requestEx.getHeader(HttpHeaders.ACCEPT); result = MediaType.APPLICATION_JSON; } }; restInvocation.initProduceProcessor(); }
### Question: AbstractRestInvocation { public String getContext(String key) { if (null == invocation \|\| null == invocation.getContext()) { return null; } return invocation.getContext(key); } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; }### Answer: @Test public void getContext() { invocation.addContext("key", "test"); assertEquals("test", restInvocation.getContext("key")); } @Test public void getContextNull() { Assert.assertNull(restInvocation.getContext("key")); }
### Question: AbstractRestInvocation { public void sendFailResponse(Throwable throwable) { if (produceProcessor == null) { produceProcessor = ProduceProcessorManager.INSTANCE.findDefaultProcessor(); } Response response = Response.createProducerFail(throwable); sendResponseQuietly(response); } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; }### Answer: @Test public void sendFailResponseNoProduceProcessor() { invocation.onStart(0); restInvocation.produceProcessor = null; restInvocation.sendFailResponse(new RuntimeExceptionWithoutStackTrace()); Assert.assertSame(ProduceProcessorManager.INSTANCE.findDefaultJsonProcessor(), restInvocation.produceProcessor); } @Test public void sendFailResponseHaveProduceProcessor() { Holder<Response> result = new Holder<>(); restInvocation = new AbstractRestInvocationForTest() { @Override protected void doInvoke() { } @Override protected void sendResponseQuietly(Response response) { result.value = response; } }; initRestInvocation(); restInvocation.produceProcessor = ProduceProcessorManager.INSTANCE.findDefaultPlainProcessor(); Throwable e = new InvocationException(Status.BAD_GATEWAY, ""); restInvocation.sendFailResponse(e); Assert.assertSame(e, result.value.getResult()); Assert.assertSame( ProduceProcessorManager.INSTANCE.findDefaultPlainProcessor(), restInvocation.produceProcessor); }
### Question: AbstractRestInvocation { protected void sendResponseQuietly(Response response) { if (invocation != null) { invocation.getInvocationStageTrace().finishHandlersResponse(); } try { sendResponse(response); } catch (Throwable e) { LOGGER.error("Failed to send rest response, operation:{}, request uri:{}", getMicroserviceQualifiedName(), requestEx.getRequestURI(), e); } } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; }### Answer: @Test public void sendResponseQuietlyException(@Mocked Response response) { restInvocation = new AbstractRestInvocationForTest() { @Override protected void doInvoke() { } @Override protected void sendResponse(Response response) { throw new RuntimeExceptionWithoutStackTrace(); } }; initRestInvocation(); restInvocation.sendResponseQuietly(response); } @Test public void sendResponseQuietlyExceptionOnNullInvocation(@Mocked Response response) { restInvocation = new AbstractRestInvocationForTest() { @Override protected void doInvoke() { } @Override protected void sendResponse(Response response) { throw new RuntimeExceptionWithoutStackTrace(""); } }; initRestInvocation(); restInvocation.invocation = null; restInvocation.sendResponseQuietly(response); }
### Question: SecurityModule implements Module { @Override public String getModuleName() { return "security"; } protected SecurityModule(); protected SecurityModule(SecurityConfig config); DataRoomMatcher getDataRoomMatcher(); static SecurityModule newServerModule(SecurityConfig config); static SecurityModule newClientModule(); void setEnabled(final boolean enabled); boolean isEnabled(); void setEnabled(Supplier<Boolean> enabled); @Override String getModuleName(); void reconfigure(SecurityConfig config); SecurityConfig getConfig(); @Override void setupModule(ModuleContext context); boolean isAllowed(QueryContext queryContext, Class<?> resourceClass, ResourcePermission permission); boolean isAllowed(QueryContext queryContext, String resourceType, ResourcePermission permission); ResourcePermission getCallerPermissions(QueryContext queryContext, String resourceType); ResourcePermission getRolePermissions(QueryContext queryContext, String resourceType, String checkedRole); ResourcePermission getResourcePermission(QueryContext queryContext, Class<?> resourceClass); ResourcePermission getResourcePermission(QueryContext queryContext, String resourceType); boolean isUserInRole(QueryContext queryContext, String role); SecurityProvider getCallerSecurityProvider(); }### Answer: @Test public void testModuleName() { Assert.assertEquals("security", securityModule.getModuleName()); }
### Question: JpaEntityRepositoryBase extends JpaRepositoryBase<T> implements ResourceRepository<T, I>, ResourceRegistryAware { @Override public T findOne(I id, QuerySpec querySpec) { String idField = getIdField().getUnderlyingName(); QuerySpec idQuerySpec = querySpec.clone(); idQuerySpec.addFilter(new FilterSpec(Arrays.asList(idField), FilterOperator.EQ, id)); List<T> results = findAll(idQuerySpec); return getUnique(results, id); } JpaEntityRepositoryBase(Class<T> entityClass); JpaEntityRepositoryBase(JpaRepositoryConfig<T> config); JpaQueryFactory getQueryFactory(); @Override T findOne(I id, QuerySpec querySpec); @Override ResourceList<T> findAll(Collection<I> ids, QuerySpec querySpec); @Override ResourceList<T> findAll(QuerySpec querySpec); @Override S create(S resource); @Override S save(S resource); @Override void delete(I id); @Override Class<T> getResourceClass(); Class<?> getEntityClass(); @Override void setResourceRegistry(ResourceRegistry resourceRegistry); ResourceField getIdField(); }### Answer: @Test public void testFindOne() { QuerySpec querySpec = new QuerySpec(TestEntity.class); TestEntity entity = repo.findOne(1L, querySpec); Assert.assertEquals("test1", entity.getStringValue()); }
### Question: ResourcePermission { public static ResourcePermission fromMethod(HttpMethod method) { ResourcePermission permission = METHODS.get(method); PreconditionUtil.verify(permission != null, "unknown method %s, expected=%s", method, METHODS); return permission; } protected ResourcePermission(); private ResourcePermission(boolean post, boolean get, boolean patch, boolean delete); static final ResourcePermission create(boolean push, boolean get, boolean patch, boolean delete); static ResourcePermission fromMethod(HttpMethod method); boolean isPostAllowed(); boolean isGetAllowed(); boolean isPatchAllowed(); boolean isDeleteAllowed(); @JsonIgnore boolean isEmpty(); ResourcePermission or(ResourcePermission other); ResourcePermission and(ResourcePermission other); ResourcePermission xor(ResourcePermission other); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static final ResourcePermission EMPTY; static final ResourcePermission ALL; static final ResourcePermission GET; static final ResourcePermission POST; static final ResourcePermission PATCH; static final ResourcePermission DELETE; }### Answer: @Test public void fromMethod() { Assert.assertEquals(ResourcePermission.GET, ResourcePermission.fromMethod(HttpMethod.GET)); Assert.assertEquals(ResourcePermission.POST, ResourcePermission.fromMethod(HttpMethod.POST)); Assert.assertEquals(ResourcePermission.DELETE, ResourcePermission.fromMethod(HttpMethod.DELETE)); Assert.assertEquals(ResourcePermission.PATCH, ResourcePermission.fromMethod(HttpMethod.PATCH)); }
### Question: ResourcePermission { @Override public String toString() { return "ResourcePermission[post=" + postAllowed + ", get=" + getAllowed + ", patch=" + patchAllowed + ", delete=" + deleteAllowed + "]"; } protected ResourcePermission(); private ResourcePermission(boolean post, boolean get, boolean patch, boolean delete); static final ResourcePermission create(boolean push, boolean get, boolean patch, boolean delete); static ResourcePermission fromMethod(HttpMethod method); boolean isPostAllowed(); boolean isGetAllowed(); boolean isPatchAllowed(); boolean isDeleteAllowed(); @JsonIgnore boolean isEmpty(); ResourcePermission or(ResourcePermission other); ResourcePermission and(ResourcePermission other); ResourcePermission xor(ResourcePermission other); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static final ResourcePermission EMPTY; static final ResourcePermission ALL; static final ResourcePermission GET; static final ResourcePermission POST; static final ResourcePermission PATCH; static final ResourcePermission DELETE; }### Answer: @Test public void string() { Assert.assertEquals("ResourcePermission[post=false, get=true, patch=false, delete=false]", ResourcePermission.GET.toString()); }
### Question: JpaClientModuleFactory implements ClientModuleFactory { @Override public JpaModule create() { return JpaModule.newClientModule(); } @Override JpaModule create(); }### Answer: @Test public void test() { ServiceLoader<ClientModuleFactory> loader = ServiceLoader.load(ClientModuleFactory.class); Iterator<ClientModuleFactory> iterator = loader.iterator(); Set<Class> moduleClasses = new HashSet<>(); while (iterator.hasNext()) { ClientModuleFactory moduleFactory = iterator.next(); Module module = moduleFactory.create(); moduleClasses.add(module.getClass()); } Assert.assertEquals(2, moduleClasses.size()); Assert.assertTrue(moduleClasses.contains(JpaModule.class)); Assert.assertTrue(moduleClasses.contains(MetaModule.class)); }
### Question: QuerydslUtils { @SuppressWarnings("unchecked") public static <T> EntityPath<T> getEntityPath(Class<T> entityClass) { Class<?> queryClass = getQueryClass(entityClass); try { String fieldName = firstToLower(entityClass.getSimpleName()); Field field = queryClass.getField(fieldName); return (EntityPath<T>) field.get(entityClass); } catch (NoSuchFieldException \| SecurityException \| IllegalArgumentException \| IllegalAccessException e) { throw new IllegalStateException("failed to access query class " + queryClass.getName(), e); } } private QuerydslUtils(); @SuppressWarnings("unchecked") static EntityPath<T> getEntityPath(Class<T> entityClass); @SuppressWarnings("unchecked") static Expression<T> get(Expression<?> path, String name); static com.querydsl.core.JoinType convertJoinType(JoinType joinType); static boolean hasManyRootsFetchesOrJoins(JPAQuery<?> query); static Class<?> getQueryClass(Class<?> entityClass); }### Answer: @Test(expected = IllegalStateException.class) public void throwExceptionWhenAccessingInvalidEntityPath() { QuerydslUtils.getEntityPath(InvalidEntity.class); }
### Question: QuerydslUtils { public static Class<?> getQueryClass(Class<?> entityClass) { String queryClassName = entityClass.getPackage().getName() + ".Q" + entityClass.getSimpleName(); try { return entityClass.getClassLoader().loadClass(queryClassName); } catch (ClassNotFoundException \| SecurityException \| IllegalArgumentException e) { throw new IllegalStateException("unable to find query class " + queryClassName, e); } } private QuerydslUtils(); @SuppressWarnings("unchecked") static EntityPath<T> getEntityPath(Class<T> entityClass); @SuppressWarnings("unchecked") static Expression<T> get(Expression<?> path, String name); static com.querydsl.core.JoinType convertJoinType(JoinType joinType); static boolean hasManyRootsFetchesOrJoins(JPAQuery<?> query); static Class<?> getQueryClass(Class<?> entityClass); }### Answer: @Test(expected = IllegalStateException.class) public void throwExceptionWhenGettingInvalidQueryClass() { QuerydslUtils.getQueryClass(InvalidEntity.class); }
### Question: QuerydslUtils { @SuppressWarnings("unchecked") public static <T> Expression<T> get(Expression<?> path, String name) { try { Class<?> clazz = path.getClass(); Field field = clazz.getField(name); return (Expression<T>) field.get(path); } catch (NoSuchFieldException \| SecurityException \| IllegalArgumentException \| IllegalAccessException e) { throw new IllegalStateException("failed get field " + path + "." + name, e); } } private QuerydslUtils(); @SuppressWarnings("unchecked") static EntityPath<T> getEntityPath(Class<T> entityClass); @SuppressWarnings("unchecked") static Expression<T> get(Expression<?> path, String name); static com.querydsl.core.JoinType convertJoinType(JoinType joinType); static boolean hasManyRootsFetchesOrJoins(JPAQuery<?> query); static Class<?> getQueryClass(Class<?> entityClass); }### Answer: @Test(expected = IllegalStateException.class) public void throwExceptionWhenFollowingInvalidPath() { Expression<?> expression = Mockito.mock(Expression.class); Mockito.when(expression.getType()).thenReturn((Class) InvalidEntity.class); QuerydslUtils.get(expression, "doesNotExist"); }
### Question: ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public String getMessage() { return errorData.getDetail(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); }### Answer: @Test public void testDetailMappedToMessage() { Assert.assertEquals(errorData.getDetail(), violation.getMessage()); Assert.assertNotNull(errorData.getDetail()); } @Test public void getMessage() { violation.getMessage(); Mockito.verify(errorData, Mockito.times(1)).getDetail(); }
### Question: QueryFactoryDiscovery { public JpaQueryFactory discoverDefaultFactory() { if (ClassUtils.existsClass("com.querydsl.jpa.impl.JPAQuery")) { return QuerydslQueryFactory.newInstance(); } else { return JpaCriteriaQueryFactory.newInstance(); } } JpaQueryFactory discoverDefaultFactory(); }### Answer: @Test public void checkDiscoverQueryDsl() { QueryFactoryDiscovery discovery = new QueryFactoryDiscovery(); Assert.assertEquals(QuerydslQueryFactory.class, discovery.discoverDefaultFactory().getClass()); } @Test public void checkDiscoverCriteriaApi() { QueryFactoryDiscovery discovery = new QueryFactoryDiscovery(); ClassLoader bootstrapClassLoader = ClassLoader.getSystemClassLoader().getParent(); ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader(); Thread.currentThread().setContextClassLoader(bootstrapClassLoader); try { Assert.assertEquals(JpaCriteriaQueryFactory.class, discovery.discoverDefaultFactory().getClass()); } finally { Thread.currentThread().setContextClassLoader(contextClassLoader); } }
### Question: JpaModule implements InitializingModule { public static JpaModule createServerModule(JpaModuleConfig config, EntityManager em, TransactionRunner transactionRunner) { return createServerModule(config, () -> em, transactionRunner); } protected JpaModule(); private JpaModule(JpaModuleConfig config, EntityManagerFactory emFactory, Supplier<EntityManager> em, TransactionRunner transactionRunner); static JpaModule newClientModule(); static JpaModule createServerModule(JpaModuleConfig config, EntityManager em, TransactionRunner transactionRunner); static JpaModule createServerModule(JpaModuleConfig config, Supplier<EntityManager> em, TransactionRunner transactionRunner); @Override String getModuleName(); @Override void setupModule(ModuleContext context); @Override void init(); EntityManager getEntityManager(); EntityManagerFactory getEntityManagerFactory(); MetaLookup getJpaMetaLookup(); boolean hasRepository(Class<?> resourceClass); JpaMetaProvider getJpaMetaProvider(); JpaModuleConfig getConfig(); }### Answer: @Test public void checkInvalidConfig() { JpaModuleConfig config = new JpaModuleConfig(); config.addRepository(JpaRepositoryConfig.create(String.class)); CrnkBoot boot = new CrnkBoot(); EntityManager em = Mockito.mock(EntityManager.class); TransactionRunner transactionManager = Mockito.mock(TransactionRunner.class); boot.addModule(JpaModule.createServerModule(config, em, transactionManager)); try { boot.boot(); } catch (IllegalStateException e) { Assert.assertEquals(e.getMessage(), "failed to gather entity informations from class java.lang.String, make sure it is probably annotated with " + "JPA annotations"); } }
### Question: Operation { @Override public boolean equals(Object o) { if (o != null && getClass() == o.getClass()) { Operation operation = (Operation) o; return CompareUtils.isEquals(op, operation.op) && CompareUtils.isEquals(path, operation.path) && CompareUtils.isEquals(value, operation.value); } return false; } Operation(); Operation(String op, String path, Resource value); String getOp(); void setOp(String op); String getPath(); void setPath(String path); Resource getValue(); void setValue(Resource value); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testEquals() { EqualsVerifier.forClass(Operation.class).usingGetClass().suppress(Warning.NONFINAL_FIELDS).verify(); }
### Question: Operation { @Override public int hashCode() { int result = op != null ? op.hashCode() : 0; result = 31 * result + (path != null ? path.hashCode() : 0); result = 31 * result + (value != null ? value.hashCode() : 0); return result; } Operation(); Operation(String op, String path, Resource value); String getOp(); void setOp(String op); String getPath(); void setPath(String path); Resource getValue(); void setValue(Resource value); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testHashCode() { Operation op1 = new Operation("a", "b", new Resource()); Operation op2 = new Operation("a", "b", new Resource()); Operation op3 = new Operation("x", "b", new Resource()); Assert.assertEquals(op1, op2); Assert.assertNotEquals(op3.hashCode(), op2.hashCode()); }
### Question: PathSpec { public static PathSpec of(String... elements) { return elements != null ? of(Arrays.asList(elements)) : null; } protected PathSpec(); protected PathSpec(String path); static PathSpec of(String... elements); static PathSpec of(List<String> elements); static PathSpec empty(); @Override PathSpec clone(); static PathSpec of(String path); List<String> getElements(); void setElements(List<String> elements); String toString(); @Override boolean equals(Object o); @Override int hashCode(); boolean isEmpty(); SortSpec sort(Direction dir); FilterSpec filter(FilterOperator operator, Object value); PathSpec append(String fieldName); }### Answer: @Test public void testSerialization() throws IOException { PathSpec pathSpec = PathSpec.of("a.b.c"); ObjectMapper objectMapper = new ObjectMapper(); String json = objectMapper.writerFor(PathSpec.class).writeValueAsString(pathSpec); Assert.assertEquals("\"a.b.c\"", json); PathSpec clone = objectMapper.readerFor(PathSpec.class).readValue(json); Assert.assertEquals(pathSpec, clone); }
### Question: FilterSpec extends AbstractPathSpec implements Comparable<FilterSpec> { @Override public FilterSpec clone() { return new FilterSpec(this); } protected FilterSpec(); FilterSpec(FilterSpec spec); FilterSpec(Object value); FilterSpec(FilterOperator operator, List<FilterSpec> expressions); FilterSpec(List<String> attributePath, FilterOperator operator, Object value); FilterSpec(PathSpec path, FilterOperator operator, Object value); private FilterSpec(PathSpec pathSpec, FilterOperator operator, Object value, List<FilterSpec> expressions); static FilterSpec and(Collection<FilterSpec> conditions); static FilterSpec and(FilterSpec... conditions); static FilterSpec or(Collection<FilterSpec> conditions); static FilterSpec or(FilterSpec... conditions); static FilterSpec not(FilterSpec expression); FilterOperator getOperator(); void setOperator(FilterOperator operator); T getValue(); void setValue(Object value); List<FilterSpec> getExpression(); void setExpression(List<FilterSpec> expression); FilterSpec addExpression(FilterSpec expr); boolean hasExpressions(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); FilterSpec normalize(); @Override FilterSpec clone(); @Override int compareTo(FilterSpec o); }### Answer: @Test public void testCloneBasic() { FilterSpec spec = new FilterSpec(Arrays.asList("name"), FilterOperator.EQ, "test"); Assert.assertEquals(spec, spec.clone()); }
### Question: FilterSpec extends AbstractPathSpec implements Comparable<FilterSpec> { static List<FilterSpec> cloneExpressions(List<FilterSpec> list, boolean normalize) { List<FilterSpec> result = new ArrayList<>(); for (FilterSpec spec : list) { if (normalize) { result.add(spec.normalize()); } else { result.add(spec.clone()); } } if (normalize) { Collections.sort(result); } return result; } protected FilterSpec(); FilterSpec(FilterSpec spec); FilterSpec(Object value); FilterSpec(FilterOperator operator, List<FilterSpec> expressions); FilterSpec(List<String> attributePath, FilterOperator operator, Object value); FilterSpec(PathSpec path, FilterOperator operator, Object value); private FilterSpec(PathSpec pathSpec, FilterOperator operator, Object value, List<FilterSpec> expressions); static FilterSpec and(Collection<FilterSpec> conditions); static FilterSpec and(FilterSpec... conditions); static FilterSpec or(Collection<FilterSpec> conditions); static FilterSpec or(FilterSpec... conditions); static FilterSpec not(FilterSpec expression); FilterOperator getOperator(); void setOperator(FilterOperator operator); T getValue(); void setValue(Object value); List<FilterSpec> getExpression(); void setExpression(List<FilterSpec> expression); FilterSpec addExpression(FilterSpec expr); boolean hasExpressions(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); FilterSpec normalize(); @Override FilterSpec clone(); @Override int compareTo(FilterSpec o); }### Answer: @Test public void testCloneExpressions() { FilterSpec spec1 = new FilterSpec(Arrays.asList("name1"), FilterOperator.EQ, "test"); FilterSpec spec2 = new FilterSpec(Arrays.asList("name2"), FilterOperator.EQ, "test"); FilterSpec andSpec = FilterSpec.and(spec1, spec2); Assert.assertEquals(andSpec, andSpec.clone()); }
### Question: ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public Path getPropertyPath() { return path; } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); }### Answer: @Test public void path() { Path path = violation.getPropertyPath(); Assert.assertEquals("name", path.toString()); Assert.assertEquals(path.toString().hashCode(), path.hashCode()); Assert.assertNotEquals(path, null); Assert.assertNotEquals(path, "not a path"); Assert.assertEquals(path, path); Iterator<Path.Node> iterator = path.iterator(); Assert.assertTrue(iterator.hasNext()); Path.Node node = iterator.next(); Assert.assertEquals("name", node.getName()); Assert.assertEquals("name", node.toString()); Assert.assertEquals(null, node.getKey()); Assert.assertEquals(ElementKind.PROPERTY, node.getKind()); try { node.isInIterable(); Assert.fail(); } catch (UnsupportedOperationException e) { } try { node.as((Class) String.class); Assert.fail(); } catch (UnsupportedOperationException e) { } Assert.assertFalse(iterator.hasNext()); }
### Question: FilterSpec extends AbstractPathSpec implements Comparable<FilterSpec> { public static FilterSpec and(Collection<FilterSpec> conditions) { return and(conditions.toArray(new FilterSpec[conditions.size()])); } protected FilterSpec(); FilterSpec(FilterSpec spec); FilterSpec(Object value); FilterSpec(FilterOperator operator, List<FilterSpec> expressions); FilterSpec(List<String> attributePath, FilterOperator operator, Object value); FilterSpec(PathSpec path, FilterOperator operator, Object value); private FilterSpec(PathSpec pathSpec, FilterOperator operator, Object value, List<FilterSpec> expressions); static FilterSpec and(Collection<FilterSpec> conditions); static FilterSpec and(FilterSpec... conditions); static FilterSpec or(Collection<FilterSpec> conditions); static FilterSpec or(FilterSpec... conditions); static FilterSpec not(FilterSpec expression); FilterOperator getOperator(); void setOperator(FilterOperator operator); T getValue(); void setValue(Object value); List<FilterSpec> getExpression(); void setExpression(List<FilterSpec> expression); FilterSpec addExpression(FilterSpec expr); boolean hasExpressions(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); FilterSpec normalize(); @Override FilterSpec clone(); @Override int compareTo(FilterSpec o); }### Answer: @Test public void testAndOneExpr() { FilterSpec spec1 = new FilterSpec(Arrays.asList("name1"), FilterOperator.EQ, "test"); FilterSpec andSpec = FilterSpec.and(spec1); Assert.assertSame(spec1, andSpec); }
### Question: FilterSpec extends AbstractPathSpec implements Comparable<FilterSpec> { public static FilterSpec or(Collection<FilterSpec> conditions) { return or(conditions.toArray(new FilterSpec[conditions.size()])); } protected FilterSpec(); FilterSpec(FilterSpec spec); FilterSpec(Object value); FilterSpec(FilterOperator operator, List<FilterSpec> expressions); FilterSpec(List<String> attributePath, FilterOperator operator, Object value); FilterSpec(PathSpec path, FilterOperator operator, Object value); private FilterSpec(PathSpec pathSpec, FilterOperator operator, Object value, List<FilterSpec> expressions); static FilterSpec and(Collection<FilterSpec> conditions); static FilterSpec and(FilterSpec... conditions); static FilterSpec or(Collection<FilterSpec> conditions); static FilterSpec or(FilterSpec... conditions); static FilterSpec not(FilterSpec expression); FilterOperator getOperator(); void setOperator(FilterOperator operator); T getValue(); void setValue(Object value); List<FilterSpec> getExpression(); void setExpression(List<FilterSpec> expression); FilterSpec addExpression(FilterSpec expr); boolean hasExpressions(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); FilterSpec normalize(); @Override FilterSpec clone(); @Override int compareTo(FilterSpec o); }### Answer: @Test public void testOrOneExpr() { FilterSpec spec1 = new FilterSpec(Arrays.asList("name1"), FilterOperator.EQ, "test"); FilterSpec orSpec = FilterSpec.or(spec1); Assert.assertSame(spec1, orSpec); }
### Question: FilterOperator { public Type getFilterType(QueryParameter queryParameter, Type attributeType) { return attributeType; } protected FilterOperator(String id); String name(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); String getName(); boolean matches(Object value1, Object value2); Type getFilterType(QueryParameter queryParameter, Type attributeType); static final FilterOperator AND; static final FilterOperator SELECT; static final FilterOperator GROUP; static final FilterOperator LIKE; static final FilterOperator OR; static final FilterOperator NOT; static final FilterOperator EQ; static final FilterOperator LT; static final FilterOperator LE; static final FilterOperator GT; static final FilterOperator GE; static final FilterOperator NEQ; }### Answer: @Test public void testLikeOperatorUsesStringType() { Assert.assertEquals(String.class, FilterOperator.LIKE.getFilterType(null, Integer.class)); } @Test public void testDefaultOperatorsUsesSameType() { Assert.assertEquals(Integer.class, FilterOperator.EQ.getFilterType(null, Integer.class)); Assert.assertEquals(Integer.class, FilterOperator.GT.getFilterType(null, Integer.class)); Assert.assertEquals(Integer.class, FilterOperator.GE.getFilterType(null, Integer.class)); Assert.assertEquals(Boolean.class, FilterOperator.LT.getFilterType(null, Boolean.class)); Assert.assertEquals(Long.class, FilterOperator.LE.getFilterType(null, Long.class)); }
### Question: ConstraintViolationImpl implements ConstraintViolation<Object> { @SuppressWarnings({"rawtypes", "unchecked"}) @Override public Class getRootBeanClass() { return resourceClass; } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); }### Answer: @Test public void getRootBeanClass() { Assert.assertEquals(Task.class, violation.getRootBeanClass()); }
### Question: FilterOperator { @Override public boolean equals(Object obj) { if (obj != null && obj instanceof FilterOperator) { FilterOperator other = (FilterOperator) obj; return CompareUtils.isEquals(id, other.id); } return false; } protected FilterOperator(String id); String name(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); String getName(); boolean matches(Object value1, Object value2); Type getFilterType(QueryParameter queryParameter, Type attributeType); static final FilterOperator AND; static final FilterOperator SELECT; static final FilterOperator GROUP; static final FilterOperator LIKE; static final FilterOperator OR; static final FilterOperator NOT; static final FilterOperator EQ; static final FilterOperator LT; static final FilterOperator LE; static final FilterOperator GT; static final FilterOperator GE; static final FilterOperator NEQ; }### Answer: @Test public void testEquals() { Assert.assertEquals(FilterOperator.AND, FilterOperator.AND); Assert.assertNotEquals(FilterOperator.AND, "notAnOperator"); Assert.assertNotEquals(FilterOperator.AND, null); Assert.assertEquals(FilterOperator.OR, FilterOperator.OR); Assert.assertEquals(FilterOperator.OR, new FilterOperator("OR") { @Override public boolean matches(Object value1, Object value2) { return false; } }); Assert.assertNotEquals(FilterOperator.AND, FilterOperator.OR); }
### Question: PagingSpecUrlBuilder { public String build(QueryAdapter queryAdapter) { QueryContext queryContext = queryAdapter.getQueryContext(); UrlBuilder urlBuilder = moduleRegistry.getUrlBuilder(); Object relationshipSourceId = requestSpec.getId(); ResourceField relationshipField = requestSpec.getRelationshipField(); ResourceInformation rootInfo; if (relationshipField == null) { rootInfo = queryAdapter.getResourceInformation(); } else { rootInfo = relationshipField.getResourceInformation(); } return urlBuilder.buildUrl(queryContext, rootInfo, relationshipSourceId, queryAdapter.toQuerySpec(), relationshipField != null ? relationshipField.getJsonName() : null, queryAdapter.isSelfLink()); } PagingSpecUrlBuilder(final ModuleRegistry moduleRegistry, final RepositoryRequestSpec requestSpec); String build(QueryAdapter queryAdapter); }### Answer: @Test public void testSelfLink() { QueryContext queryContext = new QueryContext(); queryContext.setBaseUrl("http: queryContext.setRequestPath("/relationships/self"); QuerySpecAdapter adapter = new QuerySpecAdapter(new QuerySpec(Task.class), resourceRegistry, queryContext); PagingSpecUrlBuilder urlBuilder = new PagingSpecUrlBuilder(moduleRegistry, repositoryRequestSpec); Assert.assertEquals("tasks/relationships/any", urlBuilder.build(adapter)); } @Test public void testRelatedLink() { QueryContext queryContext = new QueryContext(); queryContext.setBaseUrl("http: queryContext.setRequestPath("/related"); QuerySpecAdapter adapter = new QuerySpecAdapter(new QuerySpec(Task.class), resourceRegistry, queryContext); PagingSpecUrlBuilder urlBuilder = new PagingSpecUrlBuilder(moduleRegistry, repositoryRequestSpec); Assert.assertEquals("tasks/any", urlBuilder.build(adapter)); }
### Question: ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public Object getRootBean() { throw new UnsupportedOperationException(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); }### Answer: @Test(expected = UnsupportedOperationException.class) public void getRootBean() { violation.getRootBean(); }
### Question: NumberSizePagingBehavior extends PagingBehaviorBase<NumberSizePagingSpec> { @Override public boolean isRequired(final NumberSizePagingSpec pagingSpec) { return pagingSpec.getNumber() != 1 \|\| pagingSpec.getSize() != null; } NumberSizePagingBehavior(); @Override boolean supports(Class<? extends PagingSpec> pagingSpecType); @Override Map<String, Set<String>> serialize(final NumberSizePagingSpec pagingSpec, final String resourceType); @Override NumberSizePagingSpec deserialize(final Map<String, Set<String>> parameters); @Override NumberSizePagingSpec createEmptyPagingSpec(); @Override NumberSizePagingSpec createDefaultPagingSpec(); @Override void build(final PagedLinksInformation linksInformation, final ResourceList<?> resources, final QueryAdapter queryAdapter, final PagingSpecUrlBuilder urlBuilder); @Override boolean isRequired(final NumberSizePagingSpec pagingSpec); void setDefaultNumber(int defaultNumber); static Module createModule(); }### Answer: @Test public void testIsPagingRequired() { PagingBehavior pagingBehavior = new NumberSizePagingBehavior(); assertTrue(pagingBehavior.isRequired(new NumberSizePagingSpec(2, null))); assertTrue(pagingBehavior.isRequired(new NumberSizePagingSpec(1, 30))); assertFalse(pagingBehavior.isRequired(new NumberSizePagingSpec(1, null))); } @Test public void testIsNotRequired() { assertFalse(new NumberSizePagingBehavior().isRequired(new NumberSizePagingSpec())); }
### Question: ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public Object getLeafBean() { throw new UnsupportedOperationException(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); }### Answer: @Test(expected = UnsupportedOperationException.class) public void getLeafBean() { violation.getLeafBean(); }
### Question: ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public Object getInvalidValue() { throw new UnsupportedOperationException(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); }### Answer: @Test(expected = UnsupportedOperationException.class) public void getInvalidValue() { violation.getInvalidValue(); }
### Question: OffsetLimitPagingBehavior extends PagingBehaviorBase<OffsetLimitPagingSpec> { @Override public boolean isRequired(final OffsetLimitPagingSpec pagingSpec) { return pagingSpec.getOffset() != 0 \|\| pagingSpec.getLimit() != null; } OffsetLimitPagingBehavior(); @Override Map<String, Set<String>> serialize(final OffsetLimitPagingSpec pagingSpec, final String resourceType); @Override OffsetLimitPagingSpec deserialize(final Map<String, Set<String>> parameters); @Override OffsetLimitPagingSpec createEmptyPagingSpec(); @Override OffsetLimitPagingSpec createDefaultPagingSpec(); @Override void build(final PagedLinksInformation linksInformation, final ResourceList<?> resources, final QueryAdapter queryAdapter, final PagingSpecUrlBuilder urlBuilder); @Override boolean isRequired(final OffsetLimitPagingSpec pagingSpec); long getDefaultOffset(); void setDefaultOffset(final long defaultOffset); }### Answer: @Test public void testIsPagingRequired() { PagingBehavior pagingBehavior = new OffsetLimitPagingBehavior(); assertTrue(pagingBehavior.isRequired(new OffsetLimitPagingSpec(1L, null))); assertTrue(pagingBehavior.isRequired(new OffsetLimitPagingSpec(0L, 30L))); } @Test public void testIsNotRequired() { assertFalse(new OffsetLimitPagingBehavior().isRequired(new OffsetLimitPagingSpec())); }
### Question: IncludeRelationSpec extends IncludeSpec { @Override public IncludeRelationSpec clone() { return new IncludeRelationSpec(path.clone()); } IncludeRelationSpec(List<String> path); IncludeRelationSpec(PathSpec path); @Override IncludeRelationSpec clone(); }### Answer: @Test public void testClone() { IncludeRelationSpec spec = new IncludeRelationSpec(Arrays.asList("sortAttr")); IncludeRelationSpec duplicate = spec.clone(); Assert.assertNotSame(spec, duplicate); Assert.assertNotSame(spec.getAttributePath(), duplicate.getAttributePath()); }
### Question: IncludeFieldSpec extends IncludeSpec { public IncludeFieldSpec clone() { return new IncludeFieldSpec(path.clone()); } IncludeFieldSpec(List<String> path); IncludeFieldSpec(PathSpec path); IncludeFieldSpec clone(); }### Answer: @Test public void testClone() { IncludeFieldSpec spec = new IncludeFieldSpec(Arrays.asList("sortAttr")); IncludeFieldSpec duplicate = spec.clone(); Assert.assertNotSame(spec, duplicate); Assert.assertNotSame(spec.getAttributePath(), duplicate.getAttributePath()); }
### Question: ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public Object[] getExecutableParameters() { throw new UnsupportedOperationException(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); }### Answer: @Test(expected = UnsupportedOperationException.class) public void getExecutableParameters() { violation.getExecutableParameters(); }
### Question: SortSpec extends AbstractPathSpec implements Serializable { public Direction getDirection() { return direction; } SortSpec(List<String> path, Direction direction); SortSpec(PathSpec path, Direction direction); static SortSpec asc(List<String> expression); static SortSpec desc(List<String> attributeName); Direction getDirection(); SortSpec reverse(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override SortSpec clone(); void setDirection(Direction dir); }### Answer: @Test public void testBasic() { SortSpec spec = new SortSpec(Arrays.asList("name"), Direction.ASC); Assert.assertEquals(Direction.ASC, spec.getDirection()); Assert.assertEquals(Arrays.asList("name"), spec.getAttributePath()); }
### Question: SortSpec extends AbstractPathSpec implements Serializable { @Override public String toString() { StringBuilder b = new StringBuilder(); b.append(path.toString()); b.append(' '); b.append(direction); return b.toString(); } SortSpec(List<String> path, Direction direction); SortSpec(PathSpec path, Direction direction); static SortSpec asc(List<String> expression); static SortSpec desc(List<String> attributeName); Direction getDirection(); SortSpec reverse(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override SortSpec clone(); void setDirection(Direction dir); }### Answer: @Test public void testToString() { Assert.assertEquals("name ASC", new SortSpec(Arrays.asList("name"), Direction.ASC).toString()); Assert.assertEquals("name1.name2 ASC", new SortSpec(Arrays.asList("name1", "name2"), Direction.ASC).toString()); Assert.assertEquals("name DESC", new SortSpec(Arrays.asList("name"), Direction.DESC).toString()); }
### Question: SortSpec extends AbstractPathSpec implements Serializable { public SortSpec reverse() { return new SortSpec(path, direction == Direction.ASC ? Direction.DESC : Direction.ASC); } SortSpec(List<String> path, Direction direction); SortSpec(PathSpec path, Direction direction); static SortSpec asc(List<String> expression); static SortSpec desc(List<String> attributeName); Direction getDirection(); SortSpec reverse(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override SortSpec clone(); void setDirection(Direction dir); }### Answer: @Test public void testReverse() { SortSpec specAsc = new SortSpec(Arrays.asList("name1"), Direction.ASC); SortSpec specDesc = new SortSpec(Arrays.asList("name1"), Direction.DESC); Assert.assertEquals(specDesc, specAsc.reverse()); Assert.assertEquals(specAsc, specDesc.reverse()); }
### Question: SortSpec extends AbstractPathSpec implements Serializable { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (!super.equals(obj)) { return false; } SortSpec other = (SortSpec) obj; return direction == other.direction; } SortSpec(List<String> path, Direction direction); SortSpec(PathSpec path, Direction direction); static SortSpec asc(List<String> expression); static SortSpec desc(List<String> attributeName); Direction getDirection(); SortSpec reverse(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override SortSpec clone(); void setDirection(Direction dir); }### Answer: @Test public void testEquals() { EqualsVerifier.forClass(SortSpec.class).usingGetClass().suppress(Warning.NONFINAL_FIELDS).verify(); SortSpec spec1 = new SortSpec(Arrays.asList("name1"), Direction.ASC); SortSpec spec2 = new SortSpec(Arrays.asList("name1"), Direction.ASC); SortSpec spec3 = new SortSpec(Arrays.asList("name2"), Direction.ASC); SortSpec spec4 = new SortSpec(Arrays.asList("name1"), Direction.DESC); Assert.assertEquals(spec1, spec1); Assert.assertEquals(spec3, spec3); Assert.assertEquals(spec1, spec2); Assert.assertEquals(spec2, spec1); Assert.assertEquals(spec1.hashCode(), spec1.hashCode()); Assert.assertEquals(spec3.hashCode(), spec3.hashCode()); Assert.assertEquals(spec1.hashCode(), spec2.hashCode()); Assert.assertNotEquals(spec2, spec3); Assert.assertNotEquals(spec3, spec2); Assert.assertNotEquals(spec1, spec4); Assert.assertNotEquals(spec3, spec4); Assert.assertEquals(spec1, SortSpec.asc(Arrays.asList("name1"))); Assert.assertEquals(spec4, SortSpec.desc(Arrays.asList("name1"))); Assert.assertNotEquals(spec1, null); Assert.assertNotEquals(spec1, "test"); }
### Question: SortSpec extends AbstractPathSpec implements Serializable { @Override public SortSpec clone() { return new SortSpec(path.clone(), direction); } SortSpec(List<String> path, Direction direction); SortSpec(PathSpec path, Direction direction); static SortSpec asc(List<String> expression); static SortSpec desc(List<String> attributeName); Direction getDirection(); SortSpec reverse(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override SortSpec clone(); void setDirection(Direction dir); }### Answer: @Test public void testClone() { SortSpec sortSpec = new SortSpec(Arrays.asList("sortAttr"), Direction.ASC); SortSpec duplicate = sortSpec.clone(); Assert.assertNotSame(sortSpec, duplicate); Assert.assertNotSame(sortSpec.getAttributePath(), duplicate.getAttributePath()); Assert.assertSame(sortSpec.getDirection(), duplicate.getDirection()); }
### Question: DefaultPagedMetaInformation implements PagedMetaInformation { @Override public void setTotalResourceCount(Long totalResourceCount) { this.totalResourceCount = totalResourceCount; } @Override Long getTotalResourceCount(); @Override void setTotalResourceCount(Long totalResourceCount); }### Answer: @Test public void nonNullMustBeSerialized() throws JsonProcessingException { ObjectMapper mapper = new ObjectMapper(); ObjectWriter writer = mapper.writerFor(DefaultPagedMetaInformation.class); DefaultPagedMetaInformation metaInformation = new DefaultPagedMetaInformation(); metaInformation.setTotalResourceCount(12L); String json = writer.writeValueAsString(metaInformation); Assert.assertEquals("{\"totalResourceCount\":12}", json); }
### Question: ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public Object getExecutableReturnValue() { throw new UnsupportedOperationException(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); }### Answer: @Test(expected = UnsupportedOperationException.class) public void getExecutableReturnValue() { violation.getExecutableReturnValue(); }
### Question: SecurityModule implements Module { public ResourcePermission getResourcePermission(QueryContext queryContext, Class<?> resourceClass) { String resourceType = toType(resourceClass); return getResourcePermission(queryContext, resourceType); } protected SecurityModule(); protected SecurityModule(SecurityConfig config); DataRoomMatcher getDataRoomMatcher(); static SecurityModule newServerModule(SecurityConfig config); static SecurityModule newClientModule(); void setEnabled(final boolean enabled); boolean isEnabled(); void setEnabled(Supplier<Boolean> enabled); @Override String getModuleName(); void reconfigure(SecurityConfig config); SecurityConfig getConfig(); @Override void setupModule(ModuleContext context); boolean isAllowed(QueryContext queryContext, Class<?> resourceClass, ResourcePermission permission); boolean isAllowed(QueryContext queryContext, String resourceType, ResourcePermission permission); ResourcePermission getCallerPermissions(QueryContext queryContext, String resourceType); ResourcePermission getRolePermissions(QueryContext queryContext, String resourceType, String checkedRole); ResourcePermission getResourcePermission(QueryContext queryContext, Class<?> resourceClass); ResourcePermission getResourcePermission(QueryContext queryContext, String resourceType); boolean isUserInRole(QueryContext queryContext, String role); SecurityProvider getCallerSecurityProvider(); }### Answer: @Test public void testBlackListingOfUnknownResources() { QueryContext queryContext = Mockito.mock(QueryContext.class); Assert.assertEquals(ResourcePermission.EMPTY, securityModule.getResourcePermission(queryContext, "doesNotExist")); }
### Question: ReadOnlyResourceRepositoryBase extends ResourceRepositoryBase<T, I> { @Override public final <S extends T> S save(S resource) { throw new MethodNotAllowedException("method not allowed"); } protected ReadOnlyResourceRepositoryBase(Class<T> resourceClass); @Override final S save(S resource); @Override final S create(S resource); @Override final void delete(I id); }### Answer: @Test(expected = MethodNotAllowedException.class) public void save() { repo.save(null); }
### Question: ReadOnlyResourceRepositoryBase extends ResourceRepositoryBase<T, I> { @Override public final <S extends T> S create(S resource) { throw new MethodNotAllowedException("method not allowed"); } protected ReadOnlyResourceRepositoryBase(Class<T> resourceClass); @Override final S save(S resource); @Override final S create(S resource); @Override final void delete(I id); }### Answer: @Test(expected = MethodNotAllowedException.class) public void create() { repo.create(null); }
### Question: ReadOnlyResourceRepositoryBase extends ResourceRepositoryBase<T, I> { @Override public final void delete(I id) { throw new MethodNotAllowedException("method not allowed"); } protected ReadOnlyResourceRepositoryBase(Class<T> resourceClass); @Override final S save(S resource); @Override final S create(S resource); @Override final void delete(I id); }### Answer: @Test(expected = MethodNotAllowedException.class) public void delete() { repo.delete(null); }
### Question: InMemoryResourceRepository extends ResourceRepositoryBase<T, I> { @Override public ResourceList<T> findAll(QuerySpec querySpec) { return querySpec.apply(resources.values()); } InMemoryResourceRepository(Class<T> resourceClass); Map<I, T> getMap(); void clear(); @Override ResourceList<T> findAll(QuerySpec querySpec); @Override S save(S entity); @Override void delete(I id); @Override void setResourceRegistry(ResourceRegistry resourceRegistry); }### Answer: @Test public void testStandaloneUse() { Task task = new Task(); task.setId(131L); InMemoryResourceRepository<Task, String> repository = new InMemoryResourceRepository<>(Task.class); repository.create(task); ResourceList<Task> list = repository.findAll(new QuerySpec(Task.class)); Assert.assertEquals(list.size(), 1); }
### Question: ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public Class<S> getSourceResourceClass() { throw new UnsupportedOperationException("implement getMatcher() or this method"); } @Override Class<S> getSourceResourceClass(); @Override Class<T> getTargetResourceClass(); @Override T findOneTarget(I sourceId, String fieldName, QuerySpec querySpec); @Override ResourceList<T> findManyTargets(I sourceId, String fieldName, QuerySpec querySpec); @Override void setRelation(S source, J targetId, String fieldName); @Override void setRelations(S source, Collection<J> targetIds, String fieldName); @Override void addRelations(S source, Collection<J> targetIds, String fieldName); @Override void removeRelations(S source, Collection<J> targetIds, String fieldName); }### Answer: @Test(expected = UnsupportedOperationException.class) public void getSourceResourceClass() { repo.getSourceResourceClass(); }
### Question: ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public Class<T> getTargetResourceClass() { throw new UnsupportedOperationException("implement getMatcher() or this method"); } @Override Class<S> getSourceResourceClass(); @Override Class<T> getTargetResourceClass(); @Override T findOneTarget(I sourceId, String fieldName, QuerySpec querySpec); @Override ResourceList<T> findManyTargets(I sourceId, String fieldName, QuerySpec querySpec); @Override void setRelation(S source, J targetId, String fieldName); @Override void setRelations(S source, Collection<J> targetIds, String fieldName); @Override void addRelations(S source, Collection<J> targetIds, String fieldName); @Override void removeRelations(S source, Collection<J> targetIds, String fieldName); }### Answer: @Test(expected = UnsupportedOperationException.class) public void getTargetResourceClass() { repo.getTargetResourceClass(); }
### Question: ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public T findOneTarget(I sourceId, String fieldName, QuerySpec querySpec) { throw new MethodNotAllowedException("method not allowed"); } @Override Class<S> getSourceResourceClass(); @Override Class<T> getTargetResourceClass(); @Override T findOneTarget(I sourceId, String fieldName, QuerySpec querySpec); @Override ResourceList<T> findManyTargets(I sourceId, String fieldName, QuerySpec querySpec); @Override void setRelation(S source, J targetId, String fieldName); @Override void setRelations(S source, Collection<J> targetIds, String fieldName); @Override void addRelations(S source, Collection<J> targetIds, String fieldName); @Override void removeRelations(S source, Collection<J> targetIds, String fieldName); }### Answer: @Test(expected = MethodNotAllowedException.class) public void findOneTarget() { repo.findOneTarget(null, null, null); }
### Question: ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public ResourceList<T> findManyTargets(I sourceId, String fieldName, QuerySpec querySpec) { throw new MethodNotAllowedException("method not allowed"); } @Override Class<S> getSourceResourceClass(); @Override Class<T> getTargetResourceClass(); @Override T findOneTarget(I sourceId, String fieldName, QuerySpec querySpec); @Override ResourceList<T> findManyTargets(I sourceId, String fieldName, QuerySpec querySpec); @Override void setRelation(S source, J targetId, String fieldName); @Override void setRelations(S source, Collection<J> targetIds, String fieldName); @Override void addRelations(S source, Collection<J> targetIds, String fieldName); @Override void removeRelations(S source, Collection<J> targetIds, String fieldName); }### Answer: @Test(expected = MethodNotAllowedException.class) public void findManyTargets() { repo.findManyTargets(null, null, null); }
### Question: ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public void setRelation(S source, J targetId, String fieldName) { throw new MethodNotAllowedException("method not allowed"); } @Override Class<S> getSourceResourceClass(); @Override Class<T> getTargetResourceClass(); @Override T findOneTarget(I sourceId, String fieldName, QuerySpec querySpec); @Override ResourceList<T> findManyTargets(I sourceId, String fieldName, QuerySpec querySpec); @Override void setRelation(S source, J targetId, String fieldName); @Override void setRelations(S source, Collection<J> targetIds, String fieldName); @Override void addRelations(S source, Collection<J> targetIds, String fieldName); @Override void removeRelations(S source, Collection<J> targetIds, String fieldName); }### Answer: @Test(expected = MethodNotAllowedException.class) public void setRelation() { repo.setRelation(null, null, null); }
### Question: ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public void setRelations(S source, Collection<J> targetIds, String fieldName) { throw new MethodNotAllowedException("method not allowed"); } @Override Class<S> getSourceResourceClass(); @Override Class<T> getTargetResourceClass(); @Override T findOneTarget(I sourceId, String fieldName, QuerySpec querySpec); @Override ResourceList<T> findManyTargets(I sourceId, String fieldName, QuerySpec querySpec); @Override void setRelation(S source, J targetId, String fieldName); @Override void setRelations(S source, Collection<J> targetIds, String fieldName); @Override void addRelations(S source, Collection<J> targetIds, String fieldName); @Override void removeRelations(S source, Collection<J> targetIds, String fieldName); }### Answer: @Test(expected = MethodNotAllowedException.class) public void setRelations() { repo.setRelations(null, null, null); }
### Question: ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public <U> U unwrap(Class<U> arg0) { return null; } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); }### Answer: @Test public void unwrap() { Assert.assertNull(violation.unwrap(String.class)); }
### Question: ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public void addRelations(S source, Collection<J> targetIds, String fieldName) { throw new MethodNotAllowedException("method not allowed"); } @Override Class<S> getSourceResourceClass(); @Override Class<T> getTargetResourceClass(); @Override T findOneTarget(I sourceId, String fieldName, QuerySpec querySpec); @Override ResourceList<T> findManyTargets(I sourceId, String fieldName, QuerySpec querySpec); @Override void setRelation(S source, J targetId, String fieldName); @Override void setRelations(S source, Collection<J> targetIds, String fieldName); @Override void addRelations(S source, Collection<J> targetIds, String fieldName); @Override void removeRelations(S source, Collection<J> targetIds, String fieldName); }### Answer: @Test(expected = MethodNotAllowedException.class) public void addRelations() { repo.addRelations(null, null, null); }
### Question: ReadOnlyRelationshipRepositoryBase implements RelationshipRepository<S, I, T, J> { @Override public void removeRelations(S source, Collection<J> targetIds, String fieldName) { throw new MethodNotAllowedException("method not allowed"); } @Override Class<S> getSourceResourceClass(); @Override Class<T> getTargetResourceClass(); @Override T findOneTarget(I sourceId, String fieldName, QuerySpec querySpec); @Override ResourceList<T> findManyTargets(I sourceId, String fieldName, QuerySpec querySpec); @Override void setRelation(S source, J targetId, String fieldName); @Override void setRelations(S source, Collection<J> targetIds, String fieldName); @Override void addRelations(S source, Collection<J> targetIds, String fieldName); @Override void removeRelations(S source, Collection<J> targetIds, String fieldName); }### Answer: @Test(expected = MethodNotAllowedException.class) public void removeRelations() { repo.removeRelations(null, null, null); }
### Question: RelationshipMatcher { public boolean matches(ResourceField field) { return rules.stream().filter(it -> it.matches(field)).findAny().isPresent(); } RelationshipMatcherRule rule(); boolean matches(ResourceField field); }### Answer: @Test public void checkEmpty() { Assert.assertFalse(new RelationshipMatcher().matches(field)); }
### Question: Relationship implements MetaContainer, LinksContainer { public void setData(Nullable<Object> data) { PreconditionUtil.verify(data != null, "make use of Nullable, null not allowed"); if (data.isPresent()) { Object value = data.get(); if (value instanceof Collection) { Collection<?> col = (Collection<?>) value; if (!col.isEmpty()) { Object object = col.iterator().next(); PreconditionUtil.verify(object instanceof ResourceIdentifier, "relationship data must be an instanceof of ResourceIdentifier, got %s", object); PreconditionUtil.verify(!(object instanceof Resource), "relationship data cannot be a Resource, must be a ResourceIdentifier"); } } else { PreconditionUtil.verify(value == null \|\| value instanceof ResourceIdentifier, "value must be a ResourceIdentifier, null or collection, got %s", value); } } this.data = data; } Relationship(); Relationship(ResourceIdentifier resourceId); Relationship(List<ResourceIdentifier> resourceIds); @Override ObjectNode getMeta(); @Override void setMeta(ObjectNode meta); Nullable<Object> getData(); void setData(Nullable<Object> data); @Override ObjectNode getLinks(); @Override void setLinks(ObjectNode links); @JsonIgnore Nullable<ResourceIdentifier> getSingleData(); @JsonIgnore Nullable<List<ResourceIdentifier>> getCollectionData(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer: @Test public void serializeArray() throws IOException { Relationship relationship = new Relationship(); relationship.setData(Nullable.of(Arrays.asList(new ResourceIdentifier("a", "b")))); checkSerialize(relationship); } @Test public void serializeSingleData() throws IOException { Relationship relationship = new Relationship(); relationship.setData(Nullable.of(new ResourceIdentifier("a", "b"))); checkSerialize(relationship); } @Test public void serializeNull() throws IOException { Relationship relationship = new Relationship(); relationship.setData(Nullable.nullValue()); checkSerialize(relationship); } @Test(expected = IllegalStateException.class) public void setInvalidDataThrowsException() { Relationship relationship = new Relationship(); relationship.setData(Nullable.of("not a ResourceIdentifier")); }
### Question: Document implements MetaContainer, LinksContainer { @JsonIgnore public Nullable<List<Resource>> getCollectionData() { if (!data.isPresent()) { return Nullable.empty(); } Object value = data.get(); if (value == null) { return Nullable.of((List<Resource>) (List) Collections.emptyList()); } if (!(value instanceof Iterable)) { return Nullable.of((Collections.singletonList((Resource) value))); } return Nullable.of((List<Resource>) value); } Nullable<Object> getData(); void setData(Nullable<Object> data); @Override ObjectNode getLinks(); @Override void setLinks(ObjectNode links); List<Resource> getIncluded(); void setIncluded(List<Resource> includes); @Override ObjectNode getMeta(); @Override void setMeta(ObjectNode meta); List<ErrorData> getErrors(); void setErrors(List<ErrorData> errors); @JsonIgnore boolean isMultiple(); @JsonIgnore Nullable<Resource> getSingleData(); @Override int hashCode(); @Override boolean equals(Object obj); @JsonIgnore Nullable<List<Resource>> getCollectionData(); ObjectNode getJsonapi(); void setJsonapi(ObjectNode jsonapi); }### Answer: @Test public void getCollectionData() { Document doc = new Document(); Assert.assertFalse(doc.getCollectionData().isPresent()); doc.setData(Nullable.nullValue()); Assert.assertTrue(doc.getCollectionData().get().isEmpty()); Resource resource1 = Mockito.mock(Resource.class); doc.setData(Nullable.of(resource1)); Assert.assertEquals(1, doc.getCollectionData().get().size()); Resource resource2 = Mockito.mock(Resource.class); doc.setData(Nullable.of(Arrays.asList(resource1, resource2))); Assert.assertEquals(2, doc.getCollectionData().get().size()); }
### Question: ImmediateResult implements Result<T> { @Override public T get() { return object; } ImmediateResult(T object); @Override T get(); @Override Result<D> map(Function<T, D> function); @Override Result<T> onErrorResume(Function<? super Throwable, T> function); @Override void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer); @Override Result<T> doWork(Consumer<T> function); @Override Result<R> zipWith(Result<D> other, BiFunction<T, D, R> function); @Override Result<R> merge(Function<T, Result<R>> other); @Override Result<T> setTimeout(Duration timeout); }### Answer: @Test public void checkContextAccess() throws ExecutionException, InterruptedException { Object context = new Object(); Assert.assertFalse(resultFactory.hasThreadContext()); resultFactory.setThreadContext(context); Assert.assertSame(context, resultFactory.getThreadContext()); Assert.assertTrue(resultFactory.hasThreadContext()); ExecutorService executorService = Executors.newSingleThreadExecutor(); try { Future<?> future = executorService.submit(new Runnable() { @Override public void run() { Assert.assertFalse(resultFactory.hasThreadContext()); } }); future.get(); Assert.assertFalse(resultFactory.isAsync()); } finally { executorService.shutdownNow(); } }
### Question: ImmediateResult implements Result<T> { @Override public void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer) { throw new UnsupportedOperationException("only available for async implementations"); } ImmediateResult(T object); @Override T get(); @Override Result<D> map(Function<T, D> function); @Override Result<T> onErrorResume(Function<? super Throwable, T> function); @Override void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer); @Override Result<T> doWork(Consumer<T> function); @Override Result<R> zipWith(Result<D> other, BiFunction<T, D, R> function); @Override Result<R> merge(Function<T, Result<R>> other); @Override Result<T> setTimeout(Duration timeout); }### Answer: @Test(expected = UnsupportedOperationException.class) public void subscribeNotSupported() { Result<Object> result = resultFactory.just(new Object()); result.subscribe(null, null); }
### Question: ImmediateResult implements Result<T> { @Override public Result<T> onErrorResume(Function<? super Throwable, T> function) { throw new UnsupportedOperationException("only available for async implementations"); } ImmediateResult(T object); @Override T get(); @Override Result<D> map(Function<T, D> function); @Override Result<T> onErrorResume(Function<? super Throwable, T> function); @Override void subscribe(Consumer<T> consumer, Consumer<? super Throwable> exceptionConsumer); @Override Result<T> doWork(Consumer<T> function); @Override Result<R> zipWith(Result<D> other, BiFunction<T, D, R> function); @Override Result<R> merge(Function<T, Result<R>> other); @Override Result<T> setTimeout(Duration timeout); }### Answer: @Test(expected = UnsupportedOperationException.class) public void onErrorResumeNotSupported() { Result<Object> result = resultFactory.just(new Object()); result.onErrorResume(null); }
### Question: AbstractDocumentFilter implements DocumentFilter { @Override public Response filter(DocumentFilterContext context, DocumentFilterChain chain) { return chain.doFilter(context); } @Override Response filter(DocumentFilterContext context, DocumentFilterChain chain); }### Answer: @Test public void test() { DocumentFilterContext context = Mockito.mock(DocumentFilterContext.class); DocumentFilterChain chain = Mockito.mock(DocumentFilterChain.class); AbstractDocumentFilter filter = new AbstractDocumentFilter(); filter.filter(context, chain); Mockito.verify(chain, Mockito.times(1)).doFilter(Mockito.eq(context)); }
### Question: HierarchicalResourceRegistryPart extends ResourceRegistryPartBase { public void putPart(String prefix, ResourceRegistryPart part) { if (partMap.containsKey(prefix)) { throw new IllegalStateException("part with prefx " + prefix + " already exists"); } partMap.put(prefix, part); partList.add(part); part.addListener(childListener); } void putPart(String prefix, ResourceRegistryPart part); @Override RegistryEntry addEntry(RegistryEntry entry); @Override boolean hasEntry(Class<?> implementationClass); @Override boolean hasEntry(Type implementationType); @Override boolean hasEntry(String resourceType); @Override RegistryEntry getEntry(String resourceType); @Override RegistryEntry getEntryByPath(String resourcePath); @Override int getLatestVersion(); @Override Collection<RegistryEntry> getEntries(); @Override RegistryEntry getEntry(Class<?> implementationClass); @Override RegistryEntry getEntry(Type implementationType); }### Answer: @Test(expected = IllegalStateException.class) public void testDuplicatePartThrowsException() { HierarchicalResourceRegistryPart part = new HierarchicalResourceRegistryPart(); part.putPart("", new DefaultResourceRegistryPart()); part.putPart("", new DefaultResourceRegistryPart()); }
### Question: ExceptionMapperRegistry { int getDistanceBetweenExceptions(Class<?> clazz, Class<?> mapperTypeClazz) { int distance = 0; Class<?> superClazz = clazz; if (!mapperTypeClazz.isAssignableFrom(clazz)) { return Integer.MAX_VALUE; } while (superClazz != mapperTypeClazz) { superClazz = superClazz.getSuperclass(); distance++; } return distance; } ExceptionMapperRegistry(List<ExceptionMapperType> exceptionMappers); Optional<ExceptionMapper> findMapperFor(Class<? extends Throwable> exceptionClass); @SuppressWarnings({"rawtypes", "unchecked"}) Optional<ExceptionMapper<E>> findMapperFor(ErrorResponse errorResponse); Response toResponse(Throwable e); Response toErrorResponse(Throwable e); }### Answer: @Test public void shouldReturnIntegerMAXForNotRelatedClassesFromException() { int distance = exceptionMapperRegistry.getDistanceBetweenExceptions(Exception.class, SomeException.class); assertThat(distance).isEqualTo(Integer.MAX_VALUE); } @Test public void shouldReturn0DistanceBetweenSameClassFromException() { int distance = exceptionMapperRegistry.getDistanceBetweenExceptions(Exception.class, Exception.class); assertThat(distance).isEqualTo(0); } @Test public void shouldReturn1AsADistanceBetweenSameClassFromException() { int distance = exceptionMapperRegistry.getDistanceBetweenExceptions(SomeException.class, Exception.class); assertThat(distance).isEqualTo(1); }
### Question: ConstraintViolationImpl implements ConstraintViolation<Object> { @Override public ConstraintDescriptor<?> getConstraintDescriptor() { throw new UnsupportedOperationException(); } private ConstraintViolationImpl(ResourceRegistry resourceRegistry, ErrorData errorData, QueryContext queryContext); static ConstraintViolationImpl fromError(ResourceRegistry resourceRegistry, ErrorData error, QueryContext queryContext); ErrorData getErrorData(); Serializable getResourceId(); @Override Object getRootBean(); @Override Object getLeafBean(); @Override Object getInvalidValue(); @Override Object[] getExecutableParameters(); @Override Object getExecutableReturnValue(); @Override String getMessage(); @Override ConstraintDescriptor<?> getConstraintDescriptor(); @Override String getMessageTemplate(); @Override Path getPropertyPath(); @SuppressWarnings({"rawtypes", "unchecked"}) @Override Class getRootBeanClass(); @Override U unwrap(Class<U> arg0); }### Answer: @Test(expected = UnsupportedOperationException.class) public void getConstraintDescriptor() { violation.getConstraintDescriptor(); }
### Question: ExceptionMapperType implements Prioritizable { @Override public String toString() { return "ExceptionMapperType[" + "exceptionClass=" + exceptionClass.getName() + ", exceptionMapper=" + exceptionMapper + ']'; } ExceptionMapperType(Class<? extends Throwable> exceptionClass, ExceptionMapper exceptionMapper); Class<? extends Throwable> getExceptionClass(); ExceptionMapper getExceptionMapper(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override int getPriority(); }### Answer: @Test public void checkToString() { ExceptionMapper mapper = Mockito.mock(ExceptionMapper.class); Mockito.when(mapper.toString()).thenReturn("customMapper"); ExceptionMapperType type = new ExceptionMapperType(IllegalStateException.class, mapper); Assert.assertEquals("ExceptionMapperType[exceptionClass=java.lang.IllegalStateException, exceptionMapper=customMapper]", type.toString()); }
### Question: ValidationClientModuleFactory implements ClientModuleFactory { @Override public ValidationModule create() { return ValidationModule.create(); } @Override ValidationModule create(); }### Answer: @Test public void test() { ServiceLoader<ClientModuleFactory> loader = ServiceLoader.load(ClientModuleFactory.class); Iterator<ClientModuleFactory> iterator = loader.iterator(); Set<Class> moduleClasses = new HashSet<>(); while (iterator.hasNext()) { ClientModuleFactory moduleFactory = iterator.next(); Module module = moduleFactory.create(); moduleClasses.add(module.getClass()); } Assert.assertEquals(2, moduleClasses.size()); Assert.assertTrue(moduleClasses.contains(ValidationModule.class)); Assert.assertTrue(moduleClasses.contains(MetaModule.class)); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.