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: AESEncryptionUtil { public byte[] cbcDecrypt(byte[] data, byte[] key, byte[] ivp) { return BasicEncryptionUtil.getInstance().decrypt(HelperHolder.ALGORITHM, HelperHolder.ALGORITHM_CBC_KEY, key, ivp, data); } private AESEncryptionUtil(); static AESEncryptionUtil getInstance(); byte[] cbcEncrypt(byte[] data, byte[] key, byte[] ivp); byte[] cbcDecrypt(byte[] data, byte[] key, byte[] ivp); byte[] ecbEncrypt(byte[] data, byte[] key); byte[] ecbDecrypt(byte[] data, byte[] key); }### Answer: @Test void cbcDecrypt() throws Exception { byte[] result = AESEncryptionUtil.getInstance().cbcDecrypt(Base64.decode(cryptograph), key.getBytes(), Base64.decode(ivp)); log.info("result 's value : {}", new String(result)); Assert.assertEquals(URLDecoder.decode(palaintext), new String(result)); }
### Question: RabbitmqClientDemo implements ClientDemo { public Connection connection(ConnectionFactory connectionFactory){ Connection connection = null; try { connection = connectionFactory.newConnection(); } catch (Exception e) { log.error("connection create error", e); } return connection; } ConnectionFactory connectionFactory(); Connection connection(ConnectionFactory connectionFactory); @Override void declareQueue(); }### Answer: @Test void connection() { }
### Question: MD5Util { public String toMd5(String origin){ String re_md5 = ""; try { MessageDigest md = MessageDigest.getInstance("MD5"); md.update(origin.getBytes()); byte b[] = md.digest(); md = null; int i; StringBuffer buf = new StringBuffer(""); for (int offset = 0; offset < b.length; offset++) { i = b[offset]; if (i < 0) { i += 256; } if (i < 16) { buf.append("0"); } buf.append(Integer.toHexString(i)); } re_md5 = buf.toString(); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } return re_md5; } private MD5Util(); static MD5Util getInstance(); String toMd5(String origin); }### Answer: @Test void toMd5() { }
### Question: RSAencryptionUtil { public RSAPrivateKey getPrivateKey(Map<String, Object> keyMap){ RSAPrivateKey privateKey = (RSAPrivateKey) keyMap.get(HelperHolder.PRIVATE_KEY); return privateKey; } private RSAencryptionUtil(); static RSAencryptionUtil getInstance(); Map<String, Object> initKey(); RSAPublicKey getpublicKey(Map<String, Object> keyMap); RSAPrivateKey getPrivateKey(Map<String, Object> keyMap); byte[] encrypt(byte[] data, RSAPublicKey publicKey); byte[] decrypt(byte[] data, RSAPrivateKey privateKey); }### Answer: @Test void getPrivateKey() { }
### Question: RSAencryptionUtil { public byte[] decrypt(byte[] data, RSAPrivateKey privateKey) throws Exception{ return BasicEncryptionUtil.getInstance().decrypt(HelperHolder.ALGOROTHM_KEY,privateKey,data); } private RSAencryptionUtil(); static RSAencryptionUtil getInstance(); Map<String, Object> initKey(); RSAPublicKey getpublicKey(Map<String, Object> keyMap); RSAPrivateKey getPrivateKey(Map<String, Object> keyMap); byte[] encrypt(byte[] data, RSAPublicKey publicKey); byte[] decrypt(byte[] data, RSAPrivateKey privateKey); }### Answer: @Test void decrypt() throws Exception { }
### Question: SearchInDoubleDimArray { public static boolean findByBinarySearch(int target, int [][] array) { if (array.length <= 0){ return false; } if (array[0].length <= 0){ return false; } int rowSize = array.length; int rankSize = array[0].length; if (target < array[0][0] \|\| target > array[rowSize-1][rankSize-1]){ return false; } AtomicBoolean result = new AtomicBoolean(false); Arrays.stream(array).forEach(row -> { if (Arrays.binarySearch(row,target) >= 0){ result.set(true); } }); return result.get(); } static boolean findByBinarySearch(int target, int [][] array); static boolean convertListQuery(int target, int [][] array); static void main(String[] args); }### Answer: @Test void find() { Random random = new Random(); inputs.forEach(array -> { int randomInt = random.nextInt(40)*10; boolean reault = SearchInDoubleDimArray.findByBinarySearch(randomInt,array); System.out.println(randomInt + " result " + reault); }); }
### Question: DoubleStackArithmeticExpression { public int calculate(String expression){ Stack<Integer> vals = new Stack<>(); Stack<Character> op = new Stack<>(); for (char var : expression.toCharArray()){ } return 0; } int calculate(String expression); }### Answer: @Test void calculate() { String expression = "(2+(2*4))"; int expected = 10; int result = doubleStackArithmeticExpression.calculate(expression); Assert.assertEquals(expected,result); }
### Question: FirstMissingPositive { public int firstMissingPositive(int[] nums) { int n = nums.length; if (n == 0) { return 1; } if (n == 1) { return nums[0] == 1 ? 2 : 1; } for (int i = 0; i < n; i++) { while (nums[i] > 0 && nums[i] < n && nums[i] != nums[nums[i]]) { swap(nums, i, nums[i]); } } for (int i = 1; i < n; i++) { if (nums[i] != i) { return i; } } return nums[0] == n ? n + 1 : n; } int firstMissingPositive(int[] nums); int firstMissingPositive2(int[] nums); }### Answer: @Test void test1() { Assert.assertEquals(3, firstMissingPositive.firstMissingPositive(new int[]{1,2,0})); Assert.assertEquals(2, firstMissingPositive.firstMissingPositive(new int[]{3,4,-1,1})); Assert.assertEquals(1, firstMissingPositive.firstMissingPositive(new int[]{7,8,9,11,12})); }
### Question: FirstMissingPositive { public int firstMissingPositive2(int[] nums) { if (nums.length == 0) { return 1; } if (nums.length == 1) { return nums[0] == 1 ? 2 : 1; } int min = 1; while (contain(nums, min) \|\| min < 1) { ++min; } return min; } int firstMissingPositive(int[] nums); int firstMissingPositive2(int[] nums); }### Answer: @Test void firstMissingPositive2() { Assert.assertEquals(3, firstMissingPositive.firstMissingPositive2(new int[]{1,2,0})); Assert.assertEquals(2, firstMissingPositive.firstMissingPositive2(new int[]{3,4,-1,1})); Assert.assertEquals(1, firstMissingPositive.firstMissingPositive2(new int[]{7,8,9,11,12})); }
### Question: RabbitmqClientDemo implements ClientDemo { @Override public void declareQueue() throws IOException { Connection connection = connection(connectionFactory()); Channel channel = connection.createChannel(); try { channel.queueDeclare("demo1",true,false,false,null); }catch (IOException e){ if ("406".equals(((AMQImpl.Channel.Close) (((ShutdownSignalException)e.getCause())).getReason()).getReplyCode())){ channel = connection.createChannel(); channel.queueDelete("demo1"); channel.queueDeclare("demo1",false,false,false,null); } } } ConnectionFactory connectionFactory(); Connection connection(ConnectionFactory connectionFactory); @Override void declareQueue(); }### Answer: @Test void declareQueue() throws IOException { new RabbitmqClientDemo().declareQueue(); }
### Question: TwoSum { public int[] twoSum(int[] nums, int target) { int len = nums.length; HashMap<Integer, Integer> map = new HashMap<>(); for (int i = 0; i < len; ++i) { if (map.containsKey(nums[i])) { return new int[]{map.get(nums[i]), i}; } map.put(target - nums[i], i); } return null; } int[] twoSum(int[] nums, int target); int[] twoSum1(int[] nums, int target); }### Answer: @Test void twoSum() { }
### Question: MethodMonitorProcessor { @Around("pointcut() && @annotation(monitor)") public Object logExecutionTime(ProceedingJoinPoint joinPoint, MethodMonitor monitor) throws Throwable { MethodMonitor.LogPrintLogic logPrintLogic; try { logPrintLogic = context.getBean(monitor.logic()); }catch (Exception ex){ log.error("未找到日志打印逻辑： {}，将使用默认逻辑打印日志！", monitor.logic()); logPrintLogic = context.getBean(DefaultLogPrintLogic.class); } return logPrintLogic.build(joinPoint); } @Around("pointcut() && @annotation(monitor)") Object logExecutionTime(ProceedingJoinPoint joinPoint, MethodMonitor monitor); @Bean DefaultLogPrintLogic logPrintLogic(); }### Answer: @Test void logExecutionTime() { userService.addUser("xiaoming"); assertThrows(NullPointerException.class, () -> userService.addUser("小明", 123)); }
### Question: StaticJdkProxyDemo implements UserService { @Override public void addUser(String name) { log.warn("before add user"); userService.addUser(name); log.warn("after add user"); } @Override void addUser(String name); @Override void removeUser(String name); @Override String getUsername(String name); @Override String getUsernameFromSelf(String name); }### Answer: @Test void addUser() { staticJdkProxyDemo.addUser("xiaoming"); }
### Question: StaticJdkProxyDemo implements UserService { @Override public void removeUser(String name) { log.warn("before remove user"); userService.removeUser(name); log.warn("after remove user"); } @Override void addUser(String name); @Override void removeUser(String name); @Override String getUsername(String name); @Override String getUsernameFromSelf(String name); }### Answer: @Test void removeUser() { staticJdkProxyDemo.getUsernameFromSelf("xiaoming"); }
### Question: StaticJdkProxyDemo implements UserService { @Override public String getUsername(String name) { log.warn("before get username"); String username = userService.getUsername(name); log.warn("after get username"); return username; } @Override void addUser(String name); @Override void removeUser(String name); @Override String getUsername(String name); @Override String getUsernameFromSelf(String name); }### Answer: @Test void getUsername() { }
### Question: StaticCglibProxyDemo extends UserServiceImpl { @Override public void addUser(String name) { log.warn("before add user"); super.addUser(name); log.warn("after add user"); } @Override void addUser(String name); @Override void removeUser(String name); @Override String getUsername(String name); }### Answer: @Test void addUser() { cglibProxyDemo.addUser("xiaoming"); }
### Question: Datastore { public AllocateIdsResponse allocateIds(AllocateIdsRequest request) throws DatastoreException { try (InputStream is = remoteRpc.call("allocateIds", request)) { return AllocateIdsResponse.parseFrom(is); } catch (IOException exception) { throw invalidResponseException("allocateIds", exception); } } Datastore(RemoteRpc remoteRpc); void resetRpcCount(); int getRpcCount(); AllocateIdsResponse allocateIds(AllocateIdsRequest request); BeginTransactionResponse beginTransaction(BeginTransactionRequest request); CommitResponse commit(CommitRequest request); LookupResponse lookup(LookupRequest request); ReserveIdsResponse reserveIds(ReserveIdsRequest request); RollbackResponse rollback(RollbackRequest request); RunQueryResponse runQuery(RunQueryRequest request); }### Answer: @Test public void initializer() throws Exception { options.initializer(new HttpRequestInitializer() { @Override public void initialize(HttpRequest request) { request.getHeaders().setCookie("magic"); } }); Datastore datastore = factory.create(options.build()); MockDatastoreFactory mockClient = (MockDatastoreFactory) factory; AllocateIdsRequest request = AllocateIdsRequest.newBuilder().build(); AllocateIdsResponse response = AllocateIdsResponse.newBuilder().build(); mockClient.setNextResponse(response); assertEquals(response, datastore.allocateIds(request)); assertEquals("magic", mockClient.lastCookies.get(0)); } @Test public void allocateIds() throws Exception { AllocateIdsRequest.Builder request = AllocateIdsRequest.newBuilder(); AllocateIdsResponse.Builder response = AllocateIdsResponse.newBuilder(); expectRpc("allocateIds", request.build(), response.build()); }
### Question: Datastore { public LookupResponse lookup(LookupRequest request) throws DatastoreException { try (InputStream is = remoteRpc.call("lookup", request)) { return LookupResponse.parseFrom(is); } catch (IOException exception) { throw invalidResponseException("lookup", exception); } } Datastore(RemoteRpc remoteRpc); void resetRpcCount(); int getRpcCount(); AllocateIdsResponse allocateIds(AllocateIdsRequest request); BeginTransactionResponse beginTransaction(BeginTransactionRequest request); CommitResponse commit(CommitRequest request); LookupResponse lookup(LookupRequest request); ReserveIdsResponse reserveIds(ReserveIdsRequest request); RollbackResponse rollback(RollbackRequest request); RunQueryResponse runQuery(RunQueryRequest request); }### Answer: @Test public void lookup() throws Exception { LookupRequest.Builder request = LookupRequest.newBuilder(); LookupResponse.Builder response = LookupResponse.newBuilder(); expectRpc("lookup", request.build(), response.build()); }
### Question: Datastore { public BeginTransactionResponse beginTransaction(BeginTransactionRequest request) throws DatastoreException { try (InputStream is = remoteRpc.call("beginTransaction", request)) { return BeginTransactionResponse.parseFrom(is); } catch (IOException exception) { throw invalidResponseException("beginTransaction", exception); } } Datastore(RemoteRpc remoteRpc); void resetRpcCount(); int getRpcCount(); AllocateIdsResponse allocateIds(AllocateIdsRequest request); BeginTransactionResponse beginTransaction(BeginTransactionRequest request); CommitResponse commit(CommitRequest request); LookupResponse lookup(LookupRequest request); ReserveIdsResponse reserveIds(ReserveIdsRequest request); RollbackResponse rollback(RollbackRequest request); RunQueryResponse runQuery(RunQueryRequest request); }### Answer: @Test public void beginTransaction() throws Exception { BeginTransactionRequest.Builder request = BeginTransactionRequest.newBuilder(); BeginTransactionResponse.Builder response = BeginTransactionResponse.newBuilder(); response.setTransaction(ByteString.copyFromUtf8("project-id")); expectRpc("beginTransaction", request.build(), response.build()); }
### Question: Datastore { public CommitResponse commit(CommitRequest request) throws DatastoreException { try (InputStream is = remoteRpc.call("commit", request)) { return CommitResponse.parseFrom(is); } catch (IOException exception) { throw invalidResponseException("commit", exception); } } Datastore(RemoteRpc remoteRpc); void resetRpcCount(); int getRpcCount(); AllocateIdsResponse allocateIds(AllocateIdsRequest request); BeginTransactionResponse beginTransaction(BeginTransactionRequest request); CommitResponse commit(CommitRequest request); LookupResponse lookup(LookupRequest request); ReserveIdsResponse reserveIds(ReserveIdsRequest request); RollbackResponse rollback(RollbackRequest request); RunQueryResponse runQuery(RunQueryRequest request); }### Answer: @Test public void commit() throws Exception { CommitRequest.Builder request = CommitRequest.newBuilder(); request.setTransaction(ByteString.copyFromUtf8("project-id")); CommitResponse.Builder response = CommitResponse.newBuilder(); expectRpc("commit", request.build(), response.build()); }
### Question: Datastore { public ReserveIdsResponse reserveIds(ReserveIdsRequest request) throws DatastoreException { try (InputStream is = remoteRpc.call("reserveIds", request)) { return ReserveIdsResponse.parseFrom(is); } catch (IOException exception) { throw invalidResponseException("reserveIds", exception); } } Datastore(RemoteRpc remoteRpc); void resetRpcCount(); int getRpcCount(); AllocateIdsResponse allocateIds(AllocateIdsRequest request); BeginTransactionResponse beginTransaction(BeginTransactionRequest request); CommitResponse commit(CommitRequest request); LookupResponse lookup(LookupRequest request); ReserveIdsResponse reserveIds(ReserveIdsRequest request); RollbackResponse rollback(RollbackRequest request); RunQueryResponse runQuery(RunQueryRequest request); }### Answer: @Test public void reserveIds() throws Exception { ReserveIdsRequest.Builder request = ReserveIdsRequest.newBuilder(); ReserveIdsResponse.Builder response = ReserveIdsResponse.newBuilder(); expectRpc("reserveIds", request.build(), response.build()); }
### Question: Datastore { public RollbackResponse rollback(RollbackRequest request) throws DatastoreException { try (InputStream is = remoteRpc.call("rollback", request)) { return RollbackResponse.parseFrom(is); } catch (IOException exception) { throw invalidResponseException("rollback", exception); } } Datastore(RemoteRpc remoteRpc); void resetRpcCount(); int getRpcCount(); AllocateIdsResponse allocateIds(AllocateIdsRequest request); BeginTransactionResponse beginTransaction(BeginTransactionRequest request); CommitResponse commit(CommitRequest request); LookupResponse lookup(LookupRequest request); ReserveIdsResponse reserveIds(ReserveIdsRequest request); RollbackResponse rollback(RollbackRequest request); RunQueryResponse runQuery(RunQueryRequest request); }### Answer: @Test public void rollback() throws Exception { RollbackRequest.Builder request = RollbackRequest.newBuilder(); request.setTransaction(ByteString.copyFromUtf8("project-id")); RollbackResponse.Builder response = RollbackResponse.newBuilder(); expectRpc("rollback", request.build(), response.build()); }
### Question: Datastore { public RunQueryResponse runQuery(RunQueryRequest request) throws DatastoreException { try (InputStream is = remoteRpc.call("runQuery", request)) { return RunQueryResponse.parseFrom(is); } catch (IOException exception) { throw invalidResponseException("runQuery", exception); } } Datastore(RemoteRpc remoteRpc); void resetRpcCount(); int getRpcCount(); AllocateIdsResponse allocateIds(AllocateIdsRequest request); BeginTransactionResponse beginTransaction(BeginTransactionRequest request); CommitResponse commit(CommitRequest request); LookupResponse lookup(LookupRequest request); ReserveIdsResponse reserveIds(ReserveIdsRequest request); RollbackResponse rollback(RollbackRequest request); RunQueryResponse runQuery(RunQueryRequest request); }### Answer: @Test public void runQuery() throws Exception { RunQueryRequest.Builder request = RunQueryRequest.newBuilder(); request.getQueryBuilder(); RunQueryResponse.Builder response = RunQueryResponse.newBuilder(); response.getBatchBuilder() .setEntityResultType(EntityResult.ResultType.FULL) .setMoreResults(QueryResultBatch.MoreResultsType.NOT_FINISHED); expectRpc("runQuery", request.build(), response.build()); }
### Question: DatastoreEmulator extends Datastore { @Deprecated public synchronized void start(String emulatorDir, String projectId, String... commandLineOptions) throws DatastoreEmulatorException { checkNotNull(emulatorDir, "emulatorDir cannot be null"); checkNotNull(projectId, "projectId cannot be null"); checkState(state == State.NEW, "Cannot call start() more than once."); try { startEmulatorInternal( emulatorDir + "/cloud_datastore_emulator", projectId, Arrays.asList(commandLineOptions)); state = State.STARTED; } finally { if (state != State.STARTED) { state = State.STOPPED; } } } DatastoreEmulator(RemoteRpc rpc, String localHost, DatastoreEmulatorOptions options); void clear(); @Deprecated synchronized void start(String emulatorDir, String projectId, String... commandLineOptions); synchronized void start(); synchronized void stop(); synchronized File getProjectDirectory(); }### Answer: @Test public void testArgs() throws DatastoreEmulatorException { DatastoreEmulator datastore = new DatastoreEmulator(null, "blar", options) { @Override void startEmulatorInternal( String emulatorDir, String projectId, List<String> cmdLineOpts) { } }; try { datastore.start(null, "projectId"); fail("expected exception"); } catch (NullPointerException npe) { } try { datastore.start("path/to/emulator", null); fail("expected exception"); } catch (NullPointerException npe) { } datastore.start("path/to/emulator", "projectId"); }
### Question: Patterns { public static Pattern newMustacheTagPattern(Configuration configuration) { StringBuilder regex = new StringBuilder(); regex.append(Pattern.quote(configuration .getStringPropertyValue(EngineConfigurationKey.START_DELIMITER))); regex.append(".*?"); regex.append(Pattern.quote(configuration .getStringPropertyValue(EngineConfigurationKey.END_DELIMITER))); return Pattern.compile(regex.toString()); } private Patterns(); static Pattern newMustacheTagPattern(Configuration configuration); static Pattern newSetDelimitersContentPattern(); static Pattern newHelperIntegerLiteralPattern(); static Pattern newHelperLongLiteralPattern(); }### Answer: @Test public void testMustacheTagPattern() { String text = "{{foo }} and {{#bar}}...{{/bar}}"; Pattern tagPattern = Patterns .newMustacheTagPattern(MustacheEngineBuilder.newBuilder() .build().getConfiguration()); Matcher matcher = tagPattern.matcher(text); StringBuffer result = new StringBuffer(); int occurences = 0; while (matcher.find()) { System.out.println(matcher.group(0)); matcher.appendReplacement(result, "FOUND"); occurences++; } matcher.appendTail(result); assertEquals(3, occurences); assertEquals("FOUND and FOUND...FOUND", result.toString()); }
### Question: IOUtils { public static String toString(Reader input) throws IOException { return toString(input, DEFAULT_BUFFER_SIZE); } private IOUtils(); static String toString(Reader input); static String toString(Reader input, int bufferSize); static String toString(Reader input, int bufferSize, boolean close); static void copy(Readable in, Appendable out, int bufferSize); }### Answer: @Test public void testToString() throws IOException { assertEquals("foo", IOUtils.toString(new StringReader("foo"))); assertEquals("foo", IOUtils.toString(new StringReader("foo"), 1)); }
### Question: ReflectionResolver extends AbstractResolver { @Override public Object resolve(Object contextObject, String name, ResolutionContext context) { if (contextObject == null) { return null; } MemberWrapper wrapper; MemberKey key = MemberKey.newInstance(contextObject, name); if (memberCache != null) { wrapper = memberCache.get(key).orElse(null); } else { wrapper = findWrapper(key).orElse(null); } if (wrapper == null) { return null; } try { return wrapper.getValue(contextObject); } catch (Exception e) { throw new MustacheException( MustacheProblem.RENDER_REFLECT_INVOCATION_ERROR, e); } } ReflectionResolver(); ReflectionResolver(int priority); @Override Object resolve(Object contextObject, String name, ResolutionContext context); @Override Hint createHint(Object contextObject, String name, ResolutionContext context); @Override void init(); @Override Set<ConfigurationKey> getConfigurationKeys(); void invalidateMemberCache(Predicate<Class<?>> predicate); static final int REFLECTION_RESOLVER_PRIORITY; static final String COMPUTING_CACHE_CONSUMER_ID; static final ConfigurationKey MEMBER_CACHE_MAX_SIZE_KEY; static final ConfigurationKey HINT_FALLBACK_ENABLED_KEY; static final String GET_PREFIX; static final String IS_PREFIX; }### Answer: @Test public void testResolution() { ReflectionResolver resolver = new ReflectionResolver(); MustacheEngineBuilder.newBuilder().omitServiceLoaderConfigurationExtensions().addResolver(resolver).build(); Hammer hammer = new Hammer(); assertNull(resolver.resolve(null, "whatever", null)); assertNotNull(resolver.resolve(hammer, "age", null)); assertEquals(10, resolver.resolve(hammer, "age", null)); assertNull(resolver.resolve(hammer, "getAgeForName", null)); }
### Question: ReflectionResolver extends AbstractResolver { @Override public void init() { long memberCacheMaxSize = configuration .getLongPropertyValue(MEMBER_CACHE_MAX_SIZE_KEY); LOGGER.debug("Initialized [memberCacheMaxSize: {}]", memberCacheMaxSize); if (memberCacheMaxSize > 0) { memberCache = configuration.getComputingCacheFactory().create( COMPUTING_CACHE_CONSUMER_ID, ReflectionResolver::findWrapper, null, memberCacheMaxSize, null); } hintFallbackEnabled = configuration .getBooleanPropertyValue(HINT_FALLBACK_ENABLED_KEY); } ReflectionResolver(); ReflectionResolver(int priority); @Override Object resolve(Object contextObject, String name, ResolutionContext context); @Override Hint createHint(Object contextObject, String name, ResolutionContext context); @Override void init(); @Override Set<ConfigurationKey> getConfigurationKeys(); void invalidateMemberCache(Predicate<Class<?>> predicate); static final int REFLECTION_RESOLVER_PRIORITY; static final String COMPUTING_CACHE_CONSUMER_ID; static final ConfigurationKey MEMBER_CACHE_MAX_SIZE_KEY; static final ConfigurationKey HINT_FALLBACK_ENABLED_KEY; static final String GET_PREFIX; static final String IS_PREFIX; }### Answer: @Test(expected = IllegalStateException.class) public void testMultipleInit() { ReflectionResolver resolver = new ReflectionResolver(); MustacheEngineBuilder.newBuilder().omitServiceLoaderConfigurationExtensions().addResolver(resolver).build(); resolver.init(null); }
### Question: DateTimeFormatResolver extends TransformResolver { @Override public void init() { super.init(); customPattern = configuration .getStringPropertyValue(CUSTOM_PATTERN_KEY); LOGGER.info("Initialized [customPattern: {}]", customPattern); } DateTimeFormatResolver(); DateTimeFormatResolver(int priority); @Override Object transform(Object contextObject, String name, ResolutionContext context); @Override void init(); @Override Set<ConfigurationKey> getConfigurationKeys(); static final int DATE_TIME_FORMAT_RESOLVER_PRIORITY; static final ConfigurationKey CUSTOM_PATTERN_KEY; }### Answer: @Test(expected = IllegalStateException.class) public void testMultipleInit() { DateTimeFormatResolver resolver = new DateTimeFormatResolver(); MustacheEngineBuilder.newBuilder() .omitServiceLoaderConfigurationExtensions() .addResolver(resolver).build(); resolver.init(null); }
### Question: IndexResolver extends AbstractResolver { protected boolean notAnIndex(String name) { return !isAnIndex(name); } IndexResolver(int priority); }### Answer: @Test public void testNotAnIndex() { IndexResolver indexResolver = new IndexResolver(0) { @Override public Object resolve(Object contextObject, String name, ResolutionContext context) { return null; } }; assertTrue(indexResolver.notAnIndex("-1")); assertTrue(indexResolver.notAnIndex("size")); assertTrue(indexResolver.notAnIndex(".1")); assertTrue(indexResolver.notAnIndex("1,5")); assertFalse(indexResolver.notAnIndex("1500")); }
### Question: DummyTransformResolver extends TransformResolver { @Override public Object resolve(Object contextObject, String name, ResolutionContext context) { if (contextObject == null && matches(name)) { return marker; } else if (contextObject != null && contextObject.equals(marker)) { return performTransformation(contextObject, name, context); } return null; } DummyTransformResolver(int priority, String... matchNames); DummyTransformResolver(int priority, Transformer transformer, String... matchNames); @Override Object resolve(Object contextObject, String name, ResolutionContext context); }### Answer: @Test public void testResolution() { MustacheEngineBuilder.newBuilder() .omitServiceLoaderConfigurationExtensions() .addResolver(resolver).build(); assertNull(resolver.resolve(null, "whatever", null)); Object marker = resolver.resolve(null, "ng", null); assertNotNull(marker); assertEquals("{{FOO}}", resolver.resolve(marker, "foo", null)); }
### Question: Decorator implements Mapper { public static <T> Builder<T> decorate(T delegate) { return new Builder<T>(delegate); } private Decorator(T delegate, Map<String, Function<T, Object>> mappings, String delegateKey, Configuration configuration); static Builder<T> decorate(T delegate); static Decorator<T> decorate(T delegate, Map<String, Function<T, Object>> mappings, String delegateKey, Configuration configuration); @SuppressWarnings("unchecked") static T unwrap(T instance); @Override Object get(String key); @Override String toString(); static final String KEY_GET_DELEGATE; }### Answer: @Test public void testGetDelegate() { Hammer hammer = new Hammer(); assertEquals("EDGAR vs Edgar", engine.compileMustache("{{name}} vs {{delegate.name}}") .render(decorate(hammer).compute("name", h -> h.getName().toUpperCase()).build(engine))); assertEquals("EDGAR vs Edgar", engine.compileMustache("{{name}} vs {{foo.name}}").render( decorate(hammer).delegateKey("foo").compute("name", h -> h.getName().toUpperCase()).build(engine))); } @Test public void testNestedDecorator() { Hammer hammer = new Hammer(5); assertEquals("5:Edgar:bar", engine.compileMustache("{{age}}:{{foo}}:{{bar}}") .render(decorate(decorate(hammer).compute("foo", h -> h.getName()).build(engine)) .put("bar", "bar").build(engine))); }
### Question: MapResolver extends AbstractResolver { @SuppressWarnings("rawtypes") @Override public Object resolve(Object contextObject, String name, ResolutionContext context) { if (contextObject == null) { return null; } if (contextObject instanceof Map) { Map map = (Map) contextObject; return map.get(name); } if (contextObject instanceof Mapper) { Mapper mapper = (Mapper) contextObject; return mapper.get(name); } return null; } MapResolver(); MapResolver(int priority); @SuppressWarnings("rawtypes") @Override Object resolve(Object contextObject, String name, ResolutionContext context); @Override Hint createHint(Object contextObject, String name, ResolutionContext context); static final int MAP_RESOLVER_PRIORITY; }### Answer: @Test public void testResolution() { MapResolver resolver = new MapResolver(); assertNull(resolver.resolve(null, "foo", null)); assertNotNull( resolver.resolve(ImmutableMap.of("bar", "baz"), "bar", null)); assertNull( resolver.resolve(ImmutableMap.of("bar", "baz"), "qux", null)); }
### Question: Patterns { public static Pattern newSetDelimitersContentPattern() { return Pattern.compile("(\\S+)(\\s+)(\\S+)"); } private Patterns(); static Pattern newMustacheTagPattern(Configuration configuration); static Pattern newSetDelimitersContentPattern(); static Pattern newHelperIntegerLiteralPattern(); static Pattern newHelperLongLiteralPattern(); }### Answer: @Test public void testSetDelimitersPattern() { String set1 = "<% %>"; String set2 = "[ ]"; String set3 = "= ="; Pattern setDelimitersPattern = Patterns .newSetDelimitersContentPattern(); Matcher set1Matcher = setDelimitersPattern.matcher(set1); assertEquals(true, set1Matcher.find()); assertEquals("<%", set1Matcher.group(1)); assertEquals("%>", set1Matcher.group(3)); Matcher set2Matcher = setDelimitersPattern.matcher(set2); assertEquals(true, set2Matcher.find()); assertEquals("[", set2Matcher.group(1)); assertEquals("]", set2Matcher.group(3)); Matcher set3Matcher = setDelimitersPattern.matcher(set3); assertEquals(true, set3Matcher.find()); assertEquals("=", set3Matcher.group(1)); assertEquals("=", set3Matcher.group(3)); }
### Question: HelperExecutionHandler { static int getFirstDeterminingEqualsCharPosition(String part) { boolean stringLiteral = false; for (int i = 0; i < part.length(); i++) { if (Strings.isStringLiteralSeparator(part.charAt(i))) { if (i == 0) { return -1; } stringLiteral = !stringLiteral; } else { if (!stringLiteral && part.charAt(i) == '=') { return i; } } } return -1; } private HelperExecutionHandler(Helper helper, OptionsBuilder optionsBuilder); }### Answer: @Test public void testGetFirstDeterminingEqualsCharPosition() { assertEquals(3, HelperExecutionHandler .getFirstDeterminingEqualsCharPosition("foo=bar")); assertEquals(3, HelperExecutionHandler .getFirstDeterminingEqualsCharPosition("foo='bar='")); assertEquals(1, HelperExecutionHandler .getFirstDeterminingEqualsCharPosition("1='bar='")); assertEquals(-1, HelperExecutionHandler .getFirstDeterminingEqualsCharPosition("'m=n'")); assertEquals(-1, HelperExecutionHandler .getFirstDeterminingEqualsCharPosition(" ' m=n'")); assertEquals(-1, HelperExecutionHandler .getFirstDeterminingEqualsCharPosition("'1'")); assertEquals(-1, HelperExecutionHandler .getFirstDeterminingEqualsCharPosition("\"foo\"")); }
### Question: ConfigurationProperties { static String buildPropertyKey(String propertyName, String[] prefixParts) { return buildPropertyKey(propertyName, Strings.UNDERSCORE, prefixParts); } private ConfigurationProperties(); }### Answer: @Test public void testBuildPropertyKey() { assertEquals("org.trimou.engine.config.myPropertyName", ConfigurationProperties.buildPropertyKey("MY_PROPERTY_NAME", new String[] { ConfigurationPropertiesTest.class .getPackage().getName() })); assertEquals("org.trimou.engine.config.myPropertyName", ConfigurationProperties.buildPropertyKey("MY.PROPERTY.NAME", ".", new String[] { ConfigurationPropertiesTest.class .getPackage().getName() })); }
### Question: ConfigurationProperties { static Object convertConfigValue(Class<?> defaultValueType, Object value) { if (defaultValueType.equals(String.class)) { return value.toString(); } else if (defaultValueType.equals(Boolean.class)) { return Boolean.valueOf(value.toString()); } else if (defaultValueType.equals(Long.class)) { return Long.valueOf(value.toString()); } else if (defaultValueType.equals(Integer.class)) { return Integer.valueOf(value.toString()); } throw new IllegalStateException( "Unsupported default value type: " + defaultValueType); } private ConfigurationProperties(); }### Answer: @Test public void testConvertConfigValue() { assertEquals(10, ConfigurationProperties .convertConfigValue(Integer.class, "10")); assertEquals(10L, ConfigurationProperties.convertConfigValue(Long.class, "10")); assertEquals(Boolean.FALSE, ConfigurationProperties .convertConfigValue(Boolean.class, "10")); } @Test(expected = IllegalStateException.class) public void testConvertConfigValueFails() { ConfigurationProperties.convertConfigValue(BigDecimal.class, "10"); }
### Question: ValueWrapper extends AbstractReleaseCallbackContainer implements ResolutionContext { @Override public String getKey() { return key; } ValueWrapper(String key); Object get(); boolean isNull(); @Override String getKey(); @Override int getKeyPartIndex(); Hint getHint(); }### Answer: @Test public void testGetKey() { final AtomicReference<String> key = new AtomicReference<>(); MustacheEngineBuilder .newBuilder() .omitServiceLoaderConfigurationExtensions() .addResolver( new AbstractResolver( 1) { @Override public Object resolve(Object contextObject, String name, ResolutionContext context) { key.set(context.getKey()); return null; } }).build().compileMustache("getkey", "{{my.key.foo}}") .render(null); assertEquals("my.key.foo", key.get()); }
### Question: ValueWrapper extends AbstractReleaseCallbackContainer implements ResolutionContext { @Override public int getKeyPartIndex() { return keyPartIndex; } ValueWrapper(String key); Object get(); boolean isNull(); @Override String getKey(); @Override int getKeyPartIndex(); Hint getHint(); }### Answer: @Test public void testGetKeyPartIndex() { final List<Integer> indexes = new ArrayList<>(); MustacheEngineBuilder .newBuilder() .omitServiceLoaderConfigurationExtensions() .addResolver(new AbstractResolver(1) { @Override public Object resolve(Object contextObject, String name, ResolutionContext context) { indexes.add(context.getKeyPartIndex()); return "OK"; } }).build().compileMustache("getkeypartindex", "{{my.key.foo}}") .render(null); assertEquals(3L, indexes.size()); assertEquals(Integer.valueOf(0), indexes.get(0)); assertEquals(Integer.valueOf(1), indexes.get(1)); assertEquals(Integer.valueOf(2), indexes.get(2)); }
### Question: DefaultLiteralSupport extends AbstractConfigurationAware implements LiteralSupport { @Override public Object getLiteral(String value, MustacheTagInfo tagInfo) { if (Strings.isEmpty(value)) { return null; } Object literal = null; if (Strings.isStringLiteralSeparator(value.charAt(0))) { literal = value.substring(1, value.length() - 1); } else if (value.equals("true")) { literal = Boolean.TRUE; } else if (value.equals("false")) { literal = Boolean.FALSE; } else if (integerLiteralPattern.matcher(value).matches()) { try { literal = Integer.parseInt(value); } catch (NumberFormatException e) { LOGGER.warn("Unable to parse integer literal: " + value, e); } } else if (longLiteralPattern.matcher(value).matches()) { try { literal = Long .parseLong(value.substring(0, value.length() - 1)); } catch (NumberFormatException e) { LOGGER.warn("Unable to parse long literal: " + value, e); } } return literal; } @Override Object getLiteral(String value, MustacheTagInfo tagInfo); }### Answer: @Test public void testGetLiteral() { LiteralSupport literalSupport = new DefaultLiteralSupport(); assertNull(literalSupport.getLiteral("foo", null)); assertNull(literalSupport.getLiteral("1.0", null)); assertEquals(10, literalSupport.getLiteral("+10", null)); assertEquals(-2010, literalSupport.getLiteral("-2010", null)); assertEquals("foo", literalSupport.getLiteral("'foo'", null)); assertEquals("bar.me", literalSupport.getLiteral("\"bar.me\"", null)); assertEquals(10L, literalSupport.getLiteral("10L", null)); assertEquals(-2010L, literalSupport.getLiteral("-2010l", null)); assertNull(literalSupport.getLiteral("2.0", null)); assertEquals(Boolean.TRUE, literalSupport.getLiteral("true", null)); assertEquals(Boolean.FALSE, literalSupport.getLiteral("false", null)); }
### Question: DotKeySplitter extends AbstractConfigurationAware implements KeySplitter { @Override public Iterator<String> split(String key) { if (key.equals(Strings.DOT) \|\| key.equals(Strings.THIS) \|\| !key.contains(Strings.DOT)) { return Iterables.singletonIterator(key); } boolean separator = false; List<String> parts = new ArrayList<>(); StringBuilder buffer = new StringBuilder(); for (int i = 0; i < key.length(); i++) { if (isSeparator(key.charAt(i))) { if (!separator) { if (buffer.length() > 0) { parts.add(buffer.toString()); buffer = new StringBuilder(); } separator = true; } } else { buffer.append(key.charAt(i)); separator = false; } } if (buffer.length() > 0) { parts.add(buffer.toString()); } return parts.iterator(); } @Override Iterator<String> split(String key); }### Answer: @Test public void testSplit() { DotKeySplitter splitter = new DotKeySplitter(); assertIterator(splitter.split("a..bar:.c"), "a", "bar:", "c"); assertIterator(splitter.split(". "), " "); assertIterator(splitter.split("."), "."); assertIterator(splitter.split("foo"), "foo"); }
### Question: Patterns { public static Pattern newHelperIntegerLiteralPattern() { return Pattern.compile("(\\+\|-)?\\d{1,10}"); } private Patterns(); static Pattern newMustacheTagPattern(Configuration configuration); static Pattern newSetDelimitersContentPattern(); static Pattern newHelperIntegerLiteralPattern(); static Pattern newHelperLongLiteralPattern(); }### Answer: @Test public void testHelperIntOrLongLiteralPattern() { assertFalse(Patterns.newHelperIntegerLiteralPattern() .matcher("\"foo\"").matches()); assertTrue(Patterns.newHelperIntegerLiteralPattern().matcher("1") .matches()); assertTrue(Patterns.newHelperIntegerLiteralPattern().matcher("+12") .matches()); assertTrue(Patterns.newHelperIntegerLiteralPattern().matcher("-10000") .matches()); assertFalse(Patterns.newHelperIntegerLiteralPattern().matcher("1.0") .matches()); assertFalse(Patterns.newHelperIntegerLiteralPattern() .matcher("1000000000000").matches()); }
### Question: SegmentBases { static boolean isStandaloneLine(List<SegmentBase> line) { boolean standaloneCandidate = false; for (SegmentBase segment : line) { if (SegmentType.VALUE.equals(segment.getType())) { return false; } else if (SegmentType.TEXT.equals(segment.getType())) { if (!Strings.containsOnlyWhitespace(segment.getContent())) { return false; } } else if (isStandaloneCandidate(segment.getType())) { standaloneCandidate = true; } } return standaloneCandidate; } private SegmentBases(); }### Answer: @Test public void testIsStandaloneLine() { assertTrue(SegmentBases.isStandaloneLine(ImmutableList.of( new SegmentBase(SegmentType.LINE_SEPARATOR, Strings.LINE_SEPARATOR_LF, 0, 0), new SegmentBase(SegmentType.TEXT, " ", 0, 0), new ContainerSegmentBase(SegmentType.SECTION, "test", 0, 0)))); assertFalse(SegmentBases.isStandaloneLine(ImmutableList.of( new SegmentBase(SegmentType.LINE_SEPARATOR, Strings.LINE_SEPARATOR_LF, 0, 0), new SegmentBase(SegmentType.TEXT, "Not empty", 0, 0), new ContainerSegmentBase(SegmentType.SECTION, "test", 0, 0)))); }
### Question: EnhancedStatsCollector extends AbstractStatsCollector { public void clearData() { data.clear(); } EnhancedStatsCollector(); EnhancedStatsCollector(Predicate<String> templatePredicate, TimeUnit timeUnit); @Override void renderingStarted(MustacheRenderingEvent event); @Override void renderingFinished(MustacheRenderingEvent event); Stats getStats(Mustache mustache); Set<Stats> getStats(); Collection<ExecutionData> getRawData(Mustache mustache); void clearData(); static final String COMPUTING_CACHE_CONSUMER_ID; }### Answer: @Test public void testClearData() { EnhancedStatsCollector collector = new EnhancedStatsCollector(); Mustache mustache = MustacheEngineBuilder.newBuilder() .addMustacheListener(collector).build() .compileMustache("bar", "BAR"); mustache.render(null); assertEquals(1, collector.getStats(mustache).getFinished()); collector.clearData(); assertNull(collector.getStats(mustache)); }
### Question: EnhancedStatsCollector extends AbstractStatsCollector { public Stats getStats(Mustache mustache) { Checker.checkArgumentNotNull(mustache); ConcurrentMap<Long, ExecutionData> times = data.getIfPresent(mustache .getGeneratedId()); if (times != null) { return parseData(mustache.getName(), mustache.getGeneratedId(), times.values()); } return null; } EnhancedStatsCollector(); EnhancedStatsCollector(Predicate<String> templatePredicate, TimeUnit timeUnit); @Override void renderingStarted(MustacheRenderingEvent event); @Override void renderingFinished(MustacheRenderingEvent event); Stats getStats(Mustache mustache); Set<Stats> getStats(); Collection<ExecutionData> getRawData(Mustache mustache); void clearData(); static final String COMPUTING_CACHE_CONSUMER_ID; }### Answer: @Test public void testCustomPredicate() { EnhancedStatsCollector collector = new EnhancedStatsCollector( (t) -> false, TimeUnit.DAYS); Mustache mustache = MustacheEngineBuilder.newBuilder() .addMustacheListener(collector).build() .compileMustache("qux", "Oops"); mustache.render(null); assertNull(collector.getStats(mustache)); }
### Question: SimpleStatsCollector extends AbstractStatsCollector { public void clearData() { data.clear(); } SimpleStatsCollector(); SimpleStatsCollector(Predicate<String> templatePredicate, TimeUnit timeUnit); @Override void init(); @Override void renderingStarted(final MustacheRenderingEvent event); void clearData(); Map<Long, Long> getData(String templateId); Map<String, Map<Long, Long>> getData(); SimpleStats getSimpleStats(String templateId); Set<SimpleStats> getSimpleStats(); static final String COMPUTING_CACHE_CONSUMER_ID; }### Answer: @Test public void testClearData() { SimpleStatsCollector collector = new SimpleStatsCollector(); Mustache mustache = MustacheEngineBuilder.newBuilder() .addMustacheListener(collector).build() .compileMustache("bar", "BAR"); mustache.render(null); assertEquals(1, collector.getSimpleStats("bar").getExecutions()); collector.clearData(); assertNull(collector.getSimpleStats("bar")); }
### Question: SimpleStatsCollector extends AbstractStatsCollector { public SimpleStats getSimpleStats(String templateId) { ComputingCache<Long, AtomicLong> entry = data.getIfPresent(templateId); if (entry != null) { return new SimpleStats(templateId, entry.getAllPresent()); } return null; } SimpleStatsCollector(); SimpleStatsCollector(Predicate<String> templatePredicate, TimeUnit timeUnit); @Override void init(); @Override void renderingStarted(final MustacheRenderingEvent event); void clearData(); Map<Long, Long> getData(String templateId); Map<String, Map<Long, Long>> getData(); SimpleStats getSimpleStats(String templateId); Set<SimpleStats> getSimpleStats(); static final String COMPUTING_CACHE_CONSUMER_ID; }### Answer: @Test public void testCustomPredicate() { SimpleStatsCollector collector = new SimpleStatsCollector((t) -> false, TimeUnit.DAYS); Mustache mustache = MustacheEngineBuilder.newBuilder() .addMustacheListener(collector).build() .compileMustache("qux", "Oops"); mustache.render(null); assertNull(collector.getSimpleStats("qux")); }
### Question: Strings { public static String replace(String text, String search, String replacement) { if (isEmpty(text) \|\| isEmpty(search) \|\| replacement == null) { return text; } int start = 0; int end = text.indexOf(search, start); if (end == -1) { return text; } StringBuilder builder = new StringBuilder(); while (end != -1) { builder.append(text.substring(start, end)); builder.append(replacement); start = end + search.length(); end = text.indexOf(search, start); } builder.append(text.substring(start)); return builder.toString(); } private Strings(); static boolean isStringLiteralSeparator(char character); static boolean isEmpty(CharSequence sequence); static String uncapitalize(String word); static String capitalizeFully(String text, Character delimiter); static String replace(String text, String search, String replacement); static String removeSuffix(String text, String suffix); static List<String> split(String text, String delimiter); static boolean containsWhitespace(String text); static boolean containsOnlyWhitespace(String text); static boolean containsOnlyDigits(String text); static String repeat(String text, int times, String separator); static String substringAfter(String text, String delimiter); static boolean isListLiteralStart(char character); static boolean isListLiteralEnd(char character); static boolean isListLiteral(String value); static final String EMPTY; static final String GAP; static final String LINE_SEPARATOR; static final String LINE_SEPARATOR_LF; static final String LINE_SEPARATOR_CRLF; static final String LINE_SEPARATOR_CR; static final String SLASH; static final String FILE_SEPARATOR; static final String DOT; static final String UNDERSCORE; static final String NOT_AVAILABLE; static final String URL_PROCOTOL_FILE; static final String THIS; static final String HASH; }### Answer: @Test public void testReplace() { assertEquals("foobar", Strings.replace("foo:bar", ":", "")); }
### Question: LogHelper extends BasicValueHelper { public LogHelper(LoggerAdapter adapter, Level defaultLevel, boolean appendTemplateInfo) { Checker.checkArgumentsNotNull(adapter, defaultLevel); this.defaultLevel = defaultLevel; this.adapter = adapter; this.appendTemplateInfo = appendTemplateInfo; } LogHelper(LoggerAdapter adapter, Level defaultLevel, boolean appendTemplateInfo); @Override void execute(Options options); static Builder builder(); }### Answer: @Test public void testLogHelper() { String name = "MyLogger"; TestLoggerAdapter adapter = new TestLoggerAdapter(name); MustacheEngine engine = MustacheEngineBuilder.newBuilder() .registerHelpers(HelpersBuilder.empty() .add("log", LogHelper.builder().setDefaultLevel(Level.INFO) .setLoggerAdapter(adapter).build()) .build()) .build(); String msg = "Hello me!"; engine.compileMustache("log_helper1", "{{log \"" + msg + "\" level=\"WARN\"}}").render(null); assertEquals(Level.WARN, adapter.getLevels().get(0)); assertEquals(msg + " [log_helper1:1]", adapter.getMessages().get(0)); assertEquals(adapter.getParameters().get(0).length, 0); msg = "Hello {}!"; engine.compileMustache("log_helper2", "{{log this \"me\"}}") .render(msg); assertEquals(Level.INFO, adapter.getLevels().get(1)); assertEquals(msg + " [log_helper2:1]", adapter.getMessages().get(1)); assertEquals(adapter.getParameters().get(1).length, 1); engine = MustacheEngineBuilder.newBuilder() .registerHelpers(HelpersBuilder.empty() .add("log", LogHelper.builder().setAppendTemplateInfo(false) .setDefaultLevel(Level.INFO) .setLoggerAdapter(adapter).build()) .build()) .build(); engine.compileMustache("log_helper3", "{{log \"" + msg + "\"}}") .render(null); assertEquals(Level.INFO, adapter.getLevels().get(2)); assertEquals(msg, adapter.getMessages().get(2)); assertEquals(adapter.getParameters().get(2).length, 0); }
### Question: LogHelper extends BasicValueHelper { public static Builder builder() { return new Builder(); } LogHelper(LoggerAdapter adapter, Level defaultLevel, boolean appendTemplateInfo); @Override void execute(Options options); static Builder builder(); }### Answer: @Test public void testLogHelperValidation() { final MustacheEngine engine = MustacheEngineBuilder.newBuilder() .registerHelpers(HelpersBuilder.empty() .add("log", LogHelper.builder().build()).build()) .build(); MustacheExceptionAssert .expect(MustacheProblem.COMPILE_HELPER_VALIDATION_FAILURE) .check(() -> engine.compileMustache("log_helper_validation01", "{{#log \"Foo\"}}{{/log}}")) .check(() -> engine.compileMustache("log_helper_validation02", "{{log}}")); }
### Question: EqualsHelper extends BasicSectionHelper { public EqualsHelper() { this(false); } EqualsHelper(); EqualsHelper(boolean testInequality); @Override void execute(Options options); }### Answer: @Test public void testEqualsHelper() { MustacheEngine engine = MustacheEngineBuilder.newBuilder() .addGlobalData("archiveType", ArchiveType.class) .registerHelpers(HelpersBuilder.empty().addIsEqual() .addIsNotEqual().build()) .build(); assertEquals("EQUALS", engine.compileMustache("equals_helper1", "{{#isEq this.age this.age}}EQUALS{{/isEq}}") .render(new Hammer())); assertEquals( "EQUALS", engine .compileMustache("equals_helper2", "{{#isEq this}}EQUALS{{/isEq}}") .render(new Hammer())); assertEquals("NOT_EQUALS", engine.compileMustache("equals_helper3", "{{#isNotEq this.age}}NOT_EQUALS{{/isNotEq}}") .render(new Hammer())); assertEquals("NOT_EQUALS", engine.compileMustache("equals_helper4", "{{#isNotEq this.age this.toString}}NOT_EQUALS{{/isNotEq}}") .render(new Hammer())); assertEquals("It's a WAR!", engine .compileMustache("equals_helper5", "{{#with this.archiveType}}" + "{{#isEq archiveType.WAR}}" + "It's a WAR!" + "{{/isEq}}" + "{{#isEq archiveType.EAR}}" + "It's an EAR!" + "{{/isEq}}" + "{{/with}}") .render(new Hammer())); }
### Question: NullCheckHelper extends MatchingSectionHelper { public NullCheckHelper() { this(false); } NullCheckHelper(); NullCheckHelper(boolean testNotNull); }### Answer: @Test public void testNullCheckHelper() { MustacheEngine engine = MustacheEngineBuilder .newBuilder() .registerHelpers( HelpersBuilder.empty() .addIsNull() .addIsNotNull() .build()).build(); assertEquals( "NULL\|NOTNULL", engine.compileMustache( "nullcheck_helper1", "{{#isNull this.getNull}}NULL{{/isNull}}\|{{#isNotNull this.toString}}NOTNULL{{/isNotNull}}") .render(new Hammer())); assertEquals( "NULL", engine.compileMustache( "nullcheck_helper2", "{{#isNull this.getNull this.null}}NULL{{/isNull}}") .render(new Hammer())); assertEquals( "NULL", engine.compileMustache( "nullcheck_helper3", "{{#isNull this.getNull this.age logic=\"or\"}}NULL{{/isNull}}") .render(new Hammer())); assertEquals( "NOTNULL", engine.compileMustache( "nullcheck_helper3", "{{#isNotNull this.getNull this.age logic=\"or\"}}NOTNULL{{/isNotNull}}") .render(new Hammer())); assertEquals( "ISNULL", engine.compileMustache( "nullcheck_helper4", "{{#isNotNull this.getNull else='ISNULL'}}NOTNULL{{/isNotNull}}") .render(new Hammer())); }
### Question: Strings { public static boolean containsWhitespace(String text) { if (isEmpty(text)) { return false; } for (int i = 0; i < text.length(); i++) { if (Character.isWhitespace(text.charAt(i))) { return true; } } return false; } private Strings(); static boolean isStringLiteralSeparator(char character); static boolean isEmpty(CharSequence sequence); static String uncapitalize(String word); static String capitalizeFully(String text, Character delimiter); static String replace(String text, String search, String replacement); static String removeSuffix(String text, String suffix); static List<String> split(String text, String delimiter); static boolean containsWhitespace(String text); static boolean containsOnlyWhitespace(String text); static boolean containsOnlyDigits(String text); static String repeat(String text, int times, String separator); static String substringAfter(String text, String delimiter); static boolean isListLiteralStart(char character); static boolean isListLiteralEnd(char character); static boolean isListLiteral(String value); static final String EMPTY; static final String GAP; static final String LINE_SEPARATOR; static final String LINE_SEPARATOR_LF; static final String LINE_SEPARATOR_CRLF; static final String LINE_SEPARATOR_CR; static final String SLASH; static final String FILE_SEPARATOR; static final String DOT; static final String UNDERSCORE; static final String NOT_AVAILABLE; static final String URL_PROCOTOL_FILE; static final String THIS; static final String HASH; }### Answer: @Test public void testContainsWhitespace() { assertTrue(Strings.containsWhitespace("foo bar")); assertTrue(Strings .containsWhitespace(System.getProperty("line.separator"))); assertFalse(Strings.containsWhitespace("foobar")); }
### Question: PrettyTimeHelper extends LocaleAwareValueHelper { public static Builder builder() { return new Builder(); } PrettyTimeHelper(); PrettyTimeHelper(PrettyTimeFactory prettyTimeFactory); PrettyTimeHelper(PrettyTimeFactory factory, Converter<Object, Date> converter); @Override void init(Configuration configuration); @Override void execute(Options options); static Builder builder(); static final String COMPUTING_CACHE_CONSUMER_ID; static final String DEFAULT_NAME; }### Answer: @Test public void testCustomConverter() { final Calendar day = Calendar.getInstance(); day.set(Calendar.YEAR, day.get(Calendar.YEAR) - 1); day.set(Calendar.MONTH, day.get(Calendar.MONTH) - 1); MustacheEngine engine = MustacheEngineBuilder.newBuilder() .omitServiceLoaderConfigurationExtensions() .setLocaleSupport(FixedLocaleSupport.from(Locale.ENGLISH)) .addResolver(new ThisResolver()) .registerHelper("pretty", PrettyTimeHelper.builder() .setConverter(from -> day.getTime()).build()) .build(); assertEquals("1 year ago", engine.compileMustache("pretty_conv", "{{pretty this}}") .render(Calendar.getInstance())); }
### Question: TrimouTemplateAvailabilityProvider implements TemplateAvailabilityProvider { public boolean isTemplateAvailable(final String view, final Environment environment, final ClassLoader classLoader, final ResourceLoader resourceLoader) { if (ClassUtils.isPresent("org.trimou.Mustache", classLoader)) { final PropertyResolver resolver = new RelaxedPropertyResolver(environment, TrimouProperties.PROPERTY_PREFIX + '.'); final String prefix = resolver.getProperty("prefix", SpringResourceTemplateLocator.DEFAULT_PREFIX); final String suffix = resolver.getProperty("suffix", SpringResourceTemplateLocator.DEFAULT_SUFFIX); final String resourceLocation = prefix + view + suffix; return resourceLoader.getResource(resourceLocation).exists(); } return false; } boolean isTemplateAvailable(final String view, final Environment environment, final ClassLoader classLoader, final ResourceLoader resourceLoader); }### Answer: @Test public void availabilityOfTemplateInDefaultLocation() throws Exception { assertThat(provider.isTemplateAvailable("home", environment, getClass().getClassLoader(), resourceLoader), is(true)); assertThat(provider.isTemplateAvailable("prefix/prefixed", environment, getClass().getClassLoader(), resourceLoader), is(true)); } @Test public void availabilityOfTemplateThatDoesNotExist() throws Exception { assertThat(provider.isTemplateAvailable("unknown", environment, getClass().getClassLoader(), resourceLoader), is(false)); } @Test public void availabilityOfTemplateWithCustomPrefix() throws Exception { environment.setProperty("trimou.prefix", "classpath:/custom-templates/"); assertThat(provider.isTemplateAvailable("custom", environment, getClass().getClassLoader(), resourceLoader), is(true)); } @Test public void availabilityOfTemplateWithCustomSuffix() throws Exception { environment.setProperty("trimou.suffix", ".html"); assertThat(provider.isTemplateAvailable("suffixed", environment, getClass().getClassLoader(), resourceLoader), is(true)); }
### Question: HttpServletRequestResolver extends AbstractResolver implements MustacheListener, Validateable { @Override public Object resolve(Object contextObject, String name, ResolutionContext context) { if (contextObject != null) { return null; } if (NAME_REQUEST.equals(name)) { HttpServletRequestWrapper wrapper = REQUEST_WRAPPER.get(); if (wrapper == null) { HttpServletRequest request = RequestHolder.getCurrentRequest(); if (request != null) { wrapper = new HttpServletRequestWrapper(request); REQUEST_WRAPPER.set(wrapper); } else { LOGGER.warn("Unable to get the current HTTP request"); } } return wrapper; } return null; } HttpServletRequestResolver(); HttpServletRequestResolver(int priority); @Override Object resolve(Object contextObject, String name, ResolutionContext context); @Override void init(); @Override Set<ConfigurationKey> getConfigurationKeys(); @Override void renderingStarted(MustacheRenderingEvent event); @Override boolean isValid(); static final int SERVLET_REQUEST_RESOLVER_PRIORITY; static final ConfigurationKey ENABLED_KEY; }### Answer: @Test public void testNulltIsResolved() { HttpServletRequestResolver resolver = new HttpServletRequestResolver(); assertNull(resolver.resolve("whatever", "request", null)); assertNull(resolver.resolve(null, "foo", null)); }
### Question: Strings { public static boolean containsOnlyWhitespace(String text) { if (isEmpty(text)) { return false; } for (int i = 0; i < text.length(); i++) { if (!Character.isWhitespace(text.charAt(i))) { return false; } } return true; } private Strings(); static boolean isStringLiteralSeparator(char character); static boolean isEmpty(CharSequence sequence); static String uncapitalize(String word); static String capitalizeFully(String text, Character delimiter); static String replace(String text, String search, String replacement); static String removeSuffix(String text, String suffix); static List<String> split(String text, String delimiter); static boolean containsWhitespace(String text); static boolean containsOnlyWhitespace(String text); static boolean containsOnlyDigits(String text); static String repeat(String text, int times, String separator); static String substringAfter(String text, String delimiter); static boolean isListLiteralStart(char character); static boolean isListLiteralEnd(char character); static boolean isListLiteral(String value); static final String EMPTY; static final String GAP; static final String LINE_SEPARATOR; static final String LINE_SEPARATOR_LF; static final String LINE_SEPARATOR_CRLF; static final String LINE_SEPARATOR_CR; static final String SLASH; static final String FILE_SEPARATOR; static final String DOT; static final String UNDERSCORE; static final String NOT_AVAILABLE; static final String URL_PROCOTOL_FILE; static final String THIS; static final String HASH; }### Answer: @Test public void testContainsOnlyWhitespace() { assertTrue(Strings.containsOnlyWhitespace(" ")); assertTrue(Strings.containsOnlyWhitespace( " " + System.getProperty("line.separator"))); assertFalse(Strings.containsOnlyWhitespace(" !")); }
### Question: TrimouViewResolver extends AbstractTemplateViewResolver { @Override public boolean isCache() { return engine.getConfiguration().getBooleanPropertyValue(EngineConfigurationKey.TEMPLATE_CACHE_ENABLED) && !engine.getConfiguration().getBooleanPropertyValue(EngineConfigurationKey.DEBUG_MODE) && super.isCache(); } TrimouViewResolver(); TrimouViewResolver(final MustacheEngine engine); @Override boolean isCache(); void setEngine(final MustacheEngine engine); @Override void setPrefix(final String prefix); @Override void setSuffix(final String suffix); }### Answer: @Test public void cacheEnabled() throws Exception { assertThat(resolver.isCache(), is(true)); }
### Question: Strings { public static boolean containsOnlyDigits(String text) { if (isEmpty(text)) { return false; } for (int i = 0; i < text.length(); i++) { if (!Character.isDigit(text.charAt(i))) { return false; } } return true; } private Strings(); static boolean isStringLiteralSeparator(char character); static boolean isEmpty(CharSequence sequence); static String uncapitalize(String word); static String capitalizeFully(String text, Character delimiter); static String replace(String text, String search, String replacement); static String removeSuffix(String text, String suffix); static List<String> split(String text, String delimiter); static boolean containsWhitespace(String text); static boolean containsOnlyWhitespace(String text); static boolean containsOnlyDigits(String text); static String repeat(String text, int times, String separator); static String substringAfter(String text, String delimiter); static boolean isListLiteralStart(char character); static boolean isListLiteralEnd(char character); static boolean isListLiteral(String value); static final String EMPTY; static final String GAP; static final String LINE_SEPARATOR; static final String LINE_SEPARATOR_LF; static final String LINE_SEPARATOR_CRLF; static final String LINE_SEPARATOR_CR; static final String SLASH; static final String FILE_SEPARATOR; static final String DOT; static final String UNDERSCORE; static final String NOT_AVAILABLE; static final String URL_PROCOTOL_FILE; static final String THIS; static final String HASH; }### Answer: @Test public void testContainsOnlyDigits() { assertTrue(Strings.containsOnlyDigits("123")); assertFalse(Strings.containsOnlyDigits("5!")); }
### Question: Strings { public static String repeat(String text, int times, String separator) { if (isEmpty(text) \|\| times < 0) { return text; } if (times == 0) { return EMPTY; } StringBuilder builder = new StringBuilder(); for (int i = 0; i < times; i++) { builder.append(text); if (i + 1 < times) { builder.append(separator); } } return builder.toString(); } private Strings(); static boolean isStringLiteralSeparator(char character); static boolean isEmpty(CharSequence sequence); static String uncapitalize(String word); static String capitalizeFully(String text, Character delimiter); static String replace(String text, String search, String replacement); static String removeSuffix(String text, String suffix); static List<String> split(String text, String delimiter); static boolean containsWhitespace(String text); static boolean containsOnlyWhitespace(String text); static boolean containsOnlyDigits(String text); static String repeat(String text, int times, String separator); static String substringAfter(String text, String delimiter); static boolean isListLiteralStart(char character); static boolean isListLiteralEnd(char character); static boolean isListLiteral(String value); static final String EMPTY; static final String GAP; static final String LINE_SEPARATOR; static final String LINE_SEPARATOR_LF; static final String LINE_SEPARATOR_CRLF; static final String LINE_SEPARATOR_CR; static final String SLASH; static final String FILE_SEPARATOR; static final String DOT; static final String UNDERSCORE; static final String NOT_AVAILABLE; static final String URL_PROCOTOL_FILE; static final String THIS; static final String HASH; }### Answer: @Test public void testRepeat() { assertEquals("foo,foo", Strings.repeat("foo", 2, ",")); assertEquals("ooo", Strings.repeat("o", 3, "")); assertEquals("o", Strings.repeat("o", -3, "")); assertEquals("", Strings.repeat("ouch", 0, "")); }
### Question: Strings { public static String substringAfter(String text, String delimiter) { Checker.checkArgumentsNotNull(text, delimiter); int index = text.indexOf(delimiter); if (index == -1) { return EMPTY; } return text.substring(index + delimiter.length()); } private Strings(); static boolean isStringLiteralSeparator(char character); static boolean isEmpty(CharSequence sequence); static String uncapitalize(String word); static String capitalizeFully(String text, Character delimiter); static String replace(String text, String search, String replacement); static String removeSuffix(String text, String suffix); static List<String> split(String text, String delimiter); static boolean containsWhitespace(String text); static boolean containsOnlyWhitespace(String text); static boolean containsOnlyDigits(String text); static String repeat(String text, int times, String separator); static String substringAfter(String text, String delimiter); static boolean isListLiteralStart(char character); static boolean isListLiteralEnd(char character); static boolean isListLiteral(String value); static final String EMPTY; static final String GAP; static final String LINE_SEPARATOR; static final String LINE_SEPARATOR_LF; static final String LINE_SEPARATOR_CRLF; static final String LINE_SEPARATOR_CR; static final String SLASH; static final String FILE_SEPARATOR; static final String DOT; static final String UNDERSCORE; static final String NOT_AVAILABLE; static final String URL_PROCOTOL_FILE; static final String THIS; static final String HASH; }### Answer: @Test public void testSubstringAfter() { assertEquals("o", Strings.substringAfter("foo", "o")); assertEquals("", Strings.substringAfter("foo", "a")); }
### Question: Arrays { public static boolean contains(Object[] array, Object object) { if (array == null) { return false; } for (final Object element : array) { if ((object != null && object.equals(element)) \|\| (object == null && element == null)) { return true; } } return false; } static boolean contains(Object[] array, Object object); static final Object[] EMPTY_OBJECT_ARRAY; }### Answer: @Test public void testContains() { assertTrue(Arrays.contains(new Character[] { 'v', 'o', 'j', 't', 'a' }, 'a')); assertFalse( Arrays.contains(new Character[] { 'j', 'a', 's', 'a' }, null)); assertTrue(Arrays.contains(new Character[] { 'l', null }, null)); }
### Question: HelloWorld implements ActionBlock { public int execute(FlowContext ctx) throws FlowExecutionException { String name = (String) ctx.get(IN_NAME); String message = "Hello World! "; if (name != null) { message += name; } logger.debug("Message: {}", message); ctx.put(OUT_MESSAGE, message); return NEXT; } int execute(FlowContext ctx); }### Answer: @Test public void testHelloWorld(){ HelloWorld helloWorld = new HelloWorld(); FlowContext context = new FlowContext(); context.put("name", "John"); try { int result = helloWorld.execute(context); context.get("message"); assertEquals(ActionBlock.NEXT, result); assertEquals("Hello World! John", context.get("message")); } catch (FlowExecutionException e) { e.printStackTrace(); } }
### Question: Vehicle { protected double getSpeedMph(double timeSec){ double v = 2.0this.engine.getHorsePower()746; v = vtimeSec32.174/this.weightPounds; return Math.round(Math.sqrt(v)0.68); } Vehicle(int weightPounds, Engine engine); int getWeightPounds(); Engine getEngine(); }### Answer: @Test public void testGetSpeedMph(){ double timeSec = 10.0; int engineHorsePower = 246; int vehicleWeightPounds = 4000; Engine engine = new Engine(); engine.setHorsePower(engineHorsePower); Vehicle vehicle = new Vehicle(vehicleWeightPounds, engine); double speed = vehicle.getSpeedMph(timeSec); assertEquals("Assert vehicle (" + engineHorsePower + " hp, " + vehicleWeightPounds + " lb) speed in " + timeSec + " sec: ", 117, speed, 0.001 speed); }
### Question: TrafficDensity3 { protected double calcSpeed(Vehicle vehicle, double traction, double timeSec){ double speed = vehicle.getSpeedMph(timeSec); return Math.round(speed * traction); } Integer[] trafficByLane(Stream<TrafficUnit> stream, int trafficUnitsNumber, double timeSec, SpeedModel speedModel, double[] speedLimitByLane); }### Answer: @Test public void testCalcSpeed(){ double timeSec = 10.0; TrafficDensity3 trafficDensity = new TrafficDensity3(); Vehicle vehicle = Mockito.mock(Vehicle.class); Mockito.when(vehicle.getSpeedMph(timeSec)).thenReturn(100d); double traction = 0.2; double speed = trafficDensity.calcSpeed(vehicle, traction, timeSec); assertEquals("Assert speed (traction=" + traction + ") in " + timeSec + " sec: ", 20, speed, 0.001 * speed); }
### Question: TrafficDensity3 { protected int calcLaneNumber(int lanesCount, double[] speedLimitByLane, double speed){ for(int i = 1; i <= lanesCount; i++){ if(speed <= speedLimitByLane[i - 1]){ return i; } } return lanesCount; } Integer[] trafficByLane(Stream<TrafficUnit> stream, int trafficUnitsNumber, double timeSec, SpeedModel speedModel, double[] speedLimitByLane); }### Answer: @Test public void testCalcLaneNumber() { double[] speeds = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; double[] speedLimitByLane = {4.5, 8.5, 12.5}; int[] expectedLaneNumber = {1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3}; TrafficDensityTestCalcLaneNumber trafficDensity = new TrafficDensityTestCalcLaneNumber(); for(int i = 0; i < speeds.length; i++){ int ln = trafficDensity.calcLaneNumber(speedLimitByLane.length, speedLimitByLane, speeds[i]); assertEquals("Assert lane number of speed " + speeds + " with speed limit " + Arrays.stream(speedLimitByLane).mapToObj(Double::toString).collect(Collectors.joining(", ")), expectedLaneNumber[i], ln); } }
### Question: TrafficDensity2 { protected double calcSpeed(Vehicle vehicle, double traction, double timeSec){ double speed = vehicle.getSpeedMph(timeSec); return Math.round(speed * traction); } Integer[] trafficByLane(Stream<TrafficUnit> stream, int trafficUnitsNumber, double timeSec, SpeedModel speedModel, double[] speedLimitByLane); }### Answer: @Test public void testCalcSpeed(){ double timeSec = 10.0; TrafficDensity2 trafficDensity = new TrafficDensity2(); Vehicle vehicle = Mockito.mock(Vehicle.class); Mockito.when(vehicle.getSpeedMph(timeSec)).thenReturn(100d); double traction = 0.2; double speed = trafficDensity.calcSpeed(vehicle, traction, timeSec); assertEquals("Assert speed (traction=" + traction + ") in " + timeSec + " sec: ", 20, speed, 0.001 * speed); }
### Question: TrafficDensity2 { private CountByLane countByLane(int lanesNumber, double[] speedLimit, double speed){ for(int i = 1; i <= lanesNumber; i++){ if(speed <= speedLimit[i - 1]){ return new CountByLane(1, i); } } return new CountByLane(1, lanesNumber); } Integer[] trafficByLane(Stream<TrafficUnit> stream, int trafficUnitsNumber, double timeSec, SpeedModel speedModel, double[] speedLimitByLane); }### Answer: @Test public void testCountByLane() { int[] count ={0}; double[] speeds = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; TrafficDensity2 trafficDensity = new TrafficDensity2(){ @Override protected double calcSpeed(Vehicle vehicle, double traction, double timeSec) { return speeds[count[0]++]; } }; double timeSec = 10.0; int trafficUnitsNumber = speeds.length; double[] speedLimitByLane = {4.5, 8.5, 12.5}; Integer[] expectedCountByLane = {4, 4, 4}; Integer[] trafficByLane = trafficDensity.trafficByLane(getTrafficUnitStream(trafficUnitsNumber), trafficUnitsNumber, timeSec, FactorySpeedModel.getSpeedModel(), speedLimitByLane ); assertArrayEquals("Assert count of " + speeds.length + " vehicles by " + speedLimitByLane.length + " lanes with speed limit " + Arrays.stream(speedLimitByLane).mapToObj(Double::toString).collect(Collectors.joining(", ")), expectedCountByLane, trafficByLane); }
### Question: TrafficDensity1 { public Integer[] trafficByLane(Stream<TrafficUnit> stream, int trafficUnitsNumber, double timeSec, SpeedModel speedModel, double[] speedLimitByLane) { int lanesCount = speedLimitByLane.length; Map<Integer, Integer> trafficByLane = stream .limit(trafficUnitsNumber) .map(TrafficUnitWrapper::new) .map(tuw -> tuw.setSpeedModel(speedModel)) .map(tuw -> tuw.calcSpeed(timeSec)) .map(speed -> countByLane(lanesCount, speedLimitByLane, speed)) .collect(Collectors.groupingBy(CountByLane::getLane, Collectors.summingInt(CountByLane::getCount))); for(int i = 1; i <= lanesCount; i++){ trafficByLane.putIfAbsent(i, 0); } return trafficByLane.values().toArray(new Integer[lanesCount]); } Integer[] trafficByLane(Stream<TrafficUnit> stream, int trafficUnitsNumber, double timeSec, SpeedModel speedModel, double[] speedLimitByLane); }### Answer: @Test public void testTrafficByLane() { TrafficDensity1 trafficDensity = new TrafficDensity1(); double timeSec = 10.0; int trafficUnitsNumber = 120; double[] speedLimitByLane = {30, 50, 65}; Integer[] expectedCountByLane = {30, 30, 60}; Integer[] trafficByLane = trafficDensity.trafficByLane(getTrafficUnitStream2(trafficUnitsNumber), trafficUnitsNumber, timeSec, FactorySpeedModel.getSpeedModel(), speedLimitByLane ); assertArrayEquals("Assert count of " + trafficUnitsNumber + " vehicles by " + speedLimitByLane.length + " lanes with speed limit " + Arrays.stream(speedLimitByLane).mapToObj(Double::toString).collect(Collectors.joining(", ")), expectedCountByLane, trafficByLane); }
### Question: Asn1Buffer { public void put( byte b ) { if ( pos == buffer.length ) { extend( 1 ); } pos++; buffer[buffer.length - pos] = b; } Asn1Buffer(); int getPos(); void setPos( int pos ); void put( byte b ); void put( byte[] bytes ); ByteBuffer getBytes(); int getSize(); void clear(); @Override String toString(); }### Answer: @Test @Disabled public void testBytesPerf() { long t0 = System.currentTimeMillis(); for ( int j = 0; j < 1000; j++ ) { Asn1Buffer buffer = new Asn1Buffer(); for ( int i = 0; i < 409600; i++ ) { buffer.put( new byte[] { 0x01, ( byte ) i } ); } } long t1 = System.currentTimeMillis(); System.out.println( "Delta: " + ( t1 - t0 ) ); }
### Question: MaxValueCountItem extends ProtectedItem { @Override public boolean equals( Object o ) { if ( this == o ) { return true; } if ( o instanceof MaxValueCountItem ) { MaxValueCountItem that = ( MaxValueCountItem ) o; return items.equals( that.items ); } return false; } MaxValueCountItem( Set<MaxValueCountElem> items ); Iterator<MaxValueCountElem> iterator(); @Override int hashCode(); @Override boolean equals( Object o ); @Override String toString(); }### Answer: @Test public void testNotEqualDiffValue() throws Exception { assertFalse( maxValueCountItemA.equals( maxValueCountItemC ) ); assertFalse( maxValueCountItemC.equals( maxValueCountItemA ) ); assertFalse( maxValueCountItemA.equals( maxValueCountItemD ) ); assertFalse( maxValueCountItemD.equals( maxValueCountItemA ) ); } @Test public void testEqualsNotInstanceOf() throws Exception { assertFalse( maxValueCountItemA.equals( UndefinedNode.UNDEFINED_NODE ) ); } @Test public void testEqualsNull() throws Exception { assertFalse( maxValueCountItemA.equals( null ) ); }
### Question: RestrictedByItem extends ProtectedItem { @Override public boolean equals( Object o ) { if ( this == o ) { return true; } if ( o instanceof RestrictedByItem ) { RestrictedByItem that = ( RestrictedByItem ) o; if ( items != null ) { if ( that.items == null ) { return false; } if ( items.size() != that.items.size() ) { return false; } for ( RestrictedByElem item : items ) { if ( !that.items.contains( item ) ) { return false; } } return true; } else { return that.items == null; } } return false; } RestrictedByItem( Set<RestrictedByElem> items ); Iterator<RestrictedByElem> iterator(); @Override int hashCode(); @Override boolean equals( Object o ); @Override String toString(); }### Answer: @Test public void testEqualsNotInstanceOf() throws Exception { assertFalse( restrictedByItemA.equals( UndefinedNode.UNDEFINED_NODE ) ); } @Test public void testEqualsNull() throws Exception { assertFalse( restrictedByItemA.equals( null ) ); } @Test public void testNotEqualDiffValue() throws Exception { assertFalse( restrictedByItemA.equals( restrictedByItemC ) ); assertFalse( restrictedByItemC.equals( restrictedByItemA ) ); assertFalse( restrictedByItemA.equals( restrictedByItemD ) ); assertFalse( restrictedByItemD.equals( restrictedByItemA ) ); }
### Question: RestrictedByItem extends ProtectedItem { @Override public int hashCode() { int hash = 37; if ( items != null ) { for ( RestrictedByElem item : items ) { if ( item != null ) { hash = hash * item.hashCode(); } else { hash = hash * 37; } } } return hash; } RestrictedByItem( Set<RestrictedByElem> items ); Iterator<RestrictedByElem> iterator(); @Override int hashCode(); @Override boolean equals( Object o ); @Override String toString(); }### Answer: @Test public void testHashCodeReflexive() throws Exception { assertEquals( restrictedByItemA.hashCode(), restrictedByItemA.hashCode() ); } @Test public void testHashCodeSymmetric() throws Exception { assertEquals( restrictedByItemA.hashCode(), restrictedByItemACopy.hashCode() ); assertEquals( restrictedByItemACopy.hashCode(), restrictedByItemA.hashCode() ); } @Test public void testHashCodeTransitive() throws Exception { assertEquals( restrictedByItemA.hashCode(), restrictedByItemACopy.hashCode() ); assertEquals( restrictedByItemACopy.hashCode(), restrictedByItemB.hashCode() ); assertEquals( restrictedByItemA.hashCode(), restrictedByItemB.hashCode() ); }
### Question: AttributeValueItem extends ProtectedItem { @Override public boolean equals( Object o ) { if ( this == o ) { return true; } if ( o instanceof AttributeValueItem ) { AttributeValueItem that = ( AttributeValueItem ) o; if ( attributes != null ) { if ( ( that.attributes == null ) \|\| ( that.attributes.size() != attributes.size() ) ) { return false; } for ( Attribute attribute : attributes ) { if ( !that.attributes.contains( attribute ) ) { return false; } } return true; } else { return attributes == null; } } return false; } AttributeValueItem( Set<Attribute> attributes ); Iterator<Attribute> iterator(); @Override int hashCode(); @Override boolean equals( Object o ); @Override String toString(); }### Answer: @Test public void testEqualsNotInstanceOf() throws Exception { assertFalse( attributeValueItemA.equals( UndefinedNode.UNDEFINED_NODE ) ); } @Test public void testEqualsNull() throws Exception { assertFalse( attributeValueItemA.equals( null ) ); } @Test public void testNotEqualDiffValue() throws Exception { assertFalse( attributeValueItemA.equals( attributeValueItemC ) ); assertFalse( attributeValueItemC.equals( attributeValueItemA ) ); assertFalse( attributeValueItemA.equals( attributeValueItemD ) ); assertFalse( attributeValueItemD.equals( attributeValueItemA ) ); }
### Question: AttributeValueItem extends ProtectedItem { @Override public int hashCode() { int hash = 37; if ( attributes != null ) { for ( Attribute attribute : attributes ) { hash = hash * 17 + attribute.hashCode(); } } return hash; } AttributeValueItem( Set<Attribute> attributes ); Iterator<Attribute> iterator(); @Override int hashCode(); @Override boolean equals( Object o ); @Override String toString(); }### Answer: @Test public void testHashCodeReflexive() throws Exception { assertEquals( attributeValueItemA.hashCode(), attributeValueItemA.hashCode() ); } @Test public void testHashCodeSymmetric() throws Exception { assertEquals( attributeValueItemA.hashCode(), attributeValueItemACopy.hashCode() ); assertEquals( attributeValueItemACopy.hashCode(), attributeValueItemA.hashCode() ); } @Test public void testHashCodeTransitive() throws Exception { assertEquals( attributeValueItemA.hashCode(), attributeValueItemACopy.hashCode() ); assertEquals( attributeValueItemACopy.hashCode(), attributeValueItemB.hashCode() ); assertEquals( attributeValueItemA.hashCode(), attributeValueItemB.hashCode() ); }
### Question: ClassesItem extends ProtectedItem { @Override public boolean equals( Object o ) { if ( this == o ) { return true; } if ( o instanceof ClassesItem ) { ClassesItem that = ( ClassesItem ) o; if ( classes == null ) { return that.classes == null; } return classes.equals( that.classes ); } return false; } ClassesItem( ExprNode classes ); ExprNode getClasses(); @Override int hashCode(); @Override boolean equals( Object o ); @Override String toString(); }### Answer: @Test public void testEqualsNotInstanceOf() throws Exception { assertFalse( classesItemA.equals( UndefinedNode.UNDEFINED_NODE ) ); } @Test public void testEqualsNull() throws Exception { assertFalse( classesItemA.equals( null ) ); } @Test public void testNotEqualDiffValue() throws Exception { assertFalse( classesItemA.equals( classesItemC ) ); assertFalse( classesItemC.equals( classesItemA ) ); }
### Question: ClassesItem extends ProtectedItem { @Override public int hashCode() { int hash = 37; if ( classes != null ) { hash = hash * 17 + classes.hashCode(); } else { hash = hash * 17 + getClass().getName().hashCode(); } return hash; } ClassesItem( ExprNode classes ); ExprNode getClasses(); @Override int hashCode(); @Override boolean equals( Object o ); @Override String toString(); }### Answer: @Test public void testHashCodeReflexive() throws Exception { assertEquals( classesItemA.hashCode(), classesItemA.hashCode() ); } @Test public void testHashCodeSymmetric() throws Exception { assertEquals( classesItemA.hashCode(), classesItemACopy.hashCode() ); assertEquals( classesItemACopy.hashCode(), classesItemA.hashCode() ); } @Test public void testHashCodeTransitive() throws Exception { assertEquals( classesItemA.hashCode(), classesItemACopy.hashCode() ); assertEquals( classesItemACopy.hashCode(), classesItemB.hashCode() ); assertEquals( classesItemA.hashCode(), classesItemB.hashCode() ); }
### Question: MaxImmSubItem extends ProtectedItem { @Override public boolean equals( Object o ) { if ( this == o ) { return true; } if ( o instanceof MaxImmSubItem ) { MaxImmSubItem that = ( MaxImmSubItem ) o; return this.value == that.value; } return false; } MaxImmSubItem( int value ); int getValue(); @Override int hashCode(); @Override boolean equals( Object o ); @Override String toString(); }### Answer: @Test public void testEqualsNotInstanceOf() throws Exception { assertFalse( maxImmSubItemA.equals( UndefinedNode.UNDEFINED_NODE ) ); } @Test public void testEqualsNull() throws Exception { assertFalse( maxImmSubItemA.equals( null ) ); } @Test public void testNotEqualDiffValue() throws Exception { assertFalse( maxImmSubItemA.equals( maxImmSubItemC ) ); assertFalse( maxImmSubItemC.equals( maxImmSubItemA ) ); }
### Question: MaxImmSubItem extends ProtectedItem { @Override public int hashCode() { int hash = 37; hash = hash * 17 + value; return hash; } MaxImmSubItem( int value ); int getValue(); @Override int hashCode(); @Override boolean equals( Object o ); @Override String toString(); }### Answer: @Test public void testHashCodeReflexive() throws Exception { assertEquals( maxImmSubItemA.hashCode(), maxImmSubItemA.hashCode() ); } @Test public void testHashCodeSymmetric() throws Exception { assertEquals( maxImmSubItemA.hashCode(), maxImmSubItemACopy.hashCode() ); assertEquals( maxImmSubItemACopy.hashCode(), maxImmSubItemA.hashCode() ); } @Test public void testHashCodeTransitive() throws Exception { assertEquals( maxImmSubItemA.hashCode(), maxImmSubItemACopy.hashCode() ); assertEquals( maxImmSubItemACopy.hashCode(), maxImmSubItemB.hashCode() ); assertEquals( maxImmSubItemA.hashCode(), maxImmSubItemB.hashCode() ); }
### Question: SearchResultEntryImpl extends AbstractResponse implements SearchResultEntry { @Override public boolean equals( Object obj ) { if ( this == obj ) { return true; } if ( !super.equals( obj ) ) { return false; } if ( !( obj instanceof SearchResultEntry ) ) { return false; } SearchResultEntry resp = ( SearchResultEntry ) obj; return entry.equals( resp.getEntry() ); } SearchResultEntryImpl(); SearchResultEntryImpl( final int id ); @Override Entry getEntry(); @Override void setEntry( Entry entry ); @Override Dn getObjectName(); @Override void setObjectName( Dn objectName ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); }### Answer: @Test public void testEqualsSameObject() { SearchResultEntryImpl resp = new SearchResultEntryImpl( 5 ); assertTrue( resp.equals( resp ), "the same object should be equal" ); }
### Question: SearchResultEntryImpl extends AbstractResponse implements SearchResultEntry { @Override public int hashCode() { int hash = 37; if ( entry != null ) { hash = hash * 17 + entry.hashCode(); } hash = hash * 17 + super.hashCode(); return hash; } SearchResultEntryImpl(); SearchResultEntryImpl( final int id ); @Override Entry getEntry(); @Override void setEntry( Entry entry ); @Override Dn getObjectName(); @Override void setObjectName( Dn objectName ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); }### Answer: @Test public void testHashCodeSameObject() { SearchResultEntryImpl resp = new SearchResultEntryImpl( 5 ); assertTrue( resp.hashCode() == resp.hashCode() ); }
### Question: OpaqueExtendedResponse extends AbstractExtendedResponse { @Override public int hashCode() { int hash = 37; hash = hash * 17 + super.hashCode(); if ( responseName != null ) { hash = hash * 17 + responseName.hashCode(); } if ( responseValue != null ) { for ( byte b : responseValue ) { hash = hash * 17 + b; } } return hash; } OpaqueExtendedResponse(); OpaqueExtendedResponse( int messageId ); OpaqueExtendedResponse( String responseName ); OpaqueExtendedResponse( int messageId, String responseName ); byte[] getResponseValue(); void setResponseValue( byte[] responseValue ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); }### Answer: @Test public void testHashCodeSameObj() { ExtendedResponse resp = createStub(); assertTrue( resp.hashCode() == resp.hashCode() ); } @Test public void testHashCodeExactCopy() { ExtendedResponse resp0 = createStub(); ExtendedResponse resp1 = createStub(); assertTrue( resp0.hashCode() == resp1.hashCode() ); }
### Question: ReferralImpl implements Referral { @Override public boolean equals( Object obj ) { if ( obj == this ) { return true; } if ( obj instanceof Referral ) { Collection<String> refs = ( ( Referral ) obj ).getLdapUrls(); if ( refs.size() != urls.size() ) { return false; } Iterator<String> list = urls.iterator(); while ( list.hasNext() ) { if ( !refs.contains( list.next() ) ) { return false; } } return true; } return false; } @Override int getReferralLength(); @Override void setReferralLength( int referralLength ); @Override Collection<String> getLdapUrls(); @Override Collection<byte[]> getLdapUrlsBytes(); @Override void addLdapUrl( String url ); @Override void addLdapUrlBytes( byte[] urlBytes ); @Override void removeLdapUrl( String url ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); }### Answer: @Test public void testEqualsSameObject() { ReferralImpl refs = new ReferralImpl(); assertTrue( refs.equals( refs ), "equals method should work for the same object" ); } @Test public void testEqualsDifferentImpls() { Referral refs0 = new Referral() { public Collection<String> getLdapUrls() { return Collections.emptyList(); } public void addLdapUrl( String url ) { } public void removeLdapUrl( String url ) { } public void addLdapUrlBytes( byte[] urlBytes ) { } public Collection<byte[]> getLdapUrlsBytes() { return null; } public int getReferralLength() { return 0; } public void setReferralLength( int referralLength ) { } }; ReferralImpl refs1 = new ReferralImpl(); assertFalse( refs0.equals( refs1 ), "Object.equals() in effect because we did not redefine equals for the new impl above" ); assertTrue( refs1.equals( refs0 ), "Empty Referrals should be equal even if they are different implementation classes" ); }
### Question: ReferralImpl implements Referral { @Override public int hashCode() { int hash = 37; hash = hash * 17 + urls.size(); for ( String url : urls ) { hash = hash + url.hashCode(); } return hash; } @Override int getReferralLength(); @Override void setReferralLength( int referralLength ); @Override Collection<String> getLdapUrls(); @Override Collection<byte[]> getLdapUrlsBytes(); @Override void addLdapUrl( String url ); @Override void addLdapUrlBytes( byte[] urlBytes ); @Override void removeLdapUrl( String url ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); }### Answer: @Test public void testHashCodeSameObject() { ReferralImpl refs = new ReferralImpl(); assertTrue( refs.hashCode() == refs.hashCode() ); }
### Question: BindResponseImpl extends AbstractResultResponse implements BindResponse { @Override public boolean equals( Object obj ) { if ( obj == this ) { return true; } if ( !( obj instanceof BindResponse ) ) { return false; } if ( !super.equals( obj ) ) { return false; } BindResponse response = ( BindResponse ) obj; byte[] creds = response.getServerSaslCreds(); if ( serverSaslCreds == null ) { if ( creds != null ) { return false; } } else if ( creds == null ) { return false; } return Arrays.equals( serverSaslCreds, creds ); } BindResponseImpl(); BindResponseImpl( final int id ); @Override byte[] getServerSaslCreds(); @Override void setServerSaslCreds( byte[] serverSaslCreds ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); }### Answer: @Test public void testEqualsSameObj() { BindResponseImpl resp = new BindResponseImpl( 1 ); assertTrue( resp.equals( resp ), "same object should be equal" ); } @Test public void testEqualsNewWithSameId() { BindResponseImpl resp0 = new BindResponseImpl( 1 ); BindResponseImpl resp1 = new BindResponseImpl( 1 ); assertTrue( resp0.equals( resp1 ), "default copy with same id should be equal" ); assertTrue( resp1.equals( resp0 ), "default copy with same id should be equal" ); } @Test public void testNotEqualsNewWithDiffId() { BindResponseImpl resp0 = new BindResponseImpl( 1 ); BindResponseImpl resp1 = new BindResponseImpl( 2 ); assertFalse( resp0.equals( resp1 ), "different id objects should not be equal" ); assertFalse( resp1.equals( resp0 ), "different id objects should not be equal" ); }
### Question: BindResponseImpl extends AbstractResultResponse implements BindResponse { @Override public int hashCode() { int hash = 37; hash = hash * 17 + Arrays.hashCode( serverSaslCreds ); hash = hash * 17 + super.hashCode(); return hash; } BindResponseImpl(); BindResponseImpl( final int id ); @Override byte[] getServerSaslCreds(); @Override void setServerSaslCreds( byte[] serverSaslCreds ); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); }### Answer: @Test public void testHashCodeSameObj() { BindResponseImpl resp = new BindResponseImpl( 1 ); assertTrue( resp.hashCode() == resp.hashCode() ); } @Test public void testHashCodeNewWithSameId() { BindResponseImpl resp0 = new BindResponseImpl( 1 ); BindResponseImpl resp1 = new BindResponseImpl( 1 ); assertTrue( resp1.hashCode() == resp0.hashCode() ); }
### Question: LdapResultImpl implements LdapResult { @Override public int hashCode() { int hash = 37; if ( referral != null ) { hash = hash * 17 + referral.hashCode(); } hash = hash * 17 + resultCode.hashCode(); if ( diagnosticMessage != null ) { hash = hash * 17 + diagnosticMessage.hashCode(); } if ( matchedDn != null ) { hash = hash * 17 + matchedDn.hashCode(); } return hash; } @Override String getDiagnosticMessage(); @Override void setDiagnosticMessage( String diagnosticMessage ); @Override Dn getMatchedDn(); @Override void setMatchedDn( Dn matchedDn ); @Override ResultCodeEnum getResultCode(); @Override void setResultCode( ResultCodeEnum resultCode ); @Override Referral getReferral(); @Override boolean isReferral(); @Override void setReferral( Referral referral ); @Override boolean isDefaultSuccess(); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); }### Answer: @Test public void testHashCodeSameObj() { LdapResultImpl r0 = new LdapResultImpl(); assertTrue( r0.hashCode() == r0.hashCode() ); } @Test public void testHashCodeDefaultCopy() { LdapResultImpl r0 = new LdapResultImpl(); LdapResultImpl r1 = new LdapResultImpl(); assertTrue( r0.hashCode() == r1.hashCode() ); } @Test public void testHashCodeDiffLockableParent() { LdapResultImpl r0 = new LdapResultImpl(); LdapResultImpl r1 = new LdapResultImpl(); assertTrue( r0.hashCode() == r1.hashCode() ); }
### Question: ModifyDnRequestImpl extends AbstractAbandonableRequest implements ModifyDnRequest { @Override public int hashCode() { int hash = 37; if ( name != null ) { hash = hash * 17 + name.hashCode(); } hash = hash * 17 + ( deleteOldRdn ? 0 : 1 ); if ( newRdn != null ) { hash = hash * 17 + newRdn.hashCode(); } if ( newSuperior != null ) { hash = hash * 17 + newSuperior.hashCode(); } hash = hash * 17 + super.hashCode(); return hash; } ModifyDnRequestImpl(); @Override boolean getDeleteOldRdn(); @Override ModifyDnRequest setDeleteOldRdn( boolean deleteOldRdn ); @Override boolean isMove(); @Override Dn getName(); @Override ModifyDnRequest setName( Dn name ); @Override Rdn getNewRdn(); @Override ModifyDnRequest setNewRdn( Rdn newRdn ); @Override Dn getNewSuperior(); @Override ModifyDnRequest setNewSuperior( Dn newSuperior ); @Override ModifyDnRequest setMessageId( int messageId ); @Override ModifyDnRequest addControl( Control control ); @Override ModifyDnRequest addAllControls( Control[] controls ); @Override ModifyDnRequest removeControl( Control control ); @Override MessageTypeEnum getResponseType(); @Override ModifyDnResponse getResultResponse(); @Override int hashCode(); @Override boolean equals( Object obj ); @Override String toString(); }### Answer: @Test public void testHashCodeExactCopy0() { ModifyDnRequestImpl req0 = getRequest(); ModifyDnRequestImpl req1 = getRequest(); assertTrue( req0.hashCode() == req1.hashCode() ); }
### Question: UndefinedNode extends AbstractExprNode { @Override public boolean isLeaf() { return false; } private UndefinedNode(); @Override boolean isLeaf(); @Override Object accept( FilterVisitor visitor ); @Override boolean isSchemaAware(); @Override String toString(); static final UndefinedNode UNDEFINED_NODE; }### Answer: @Test public void testIsLeaf() throws Exception { assertFalse( undefinedNode.isLeaf() ); }
### Question: UndefinedNode extends AbstractExprNode { @Override public boolean isSchemaAware() { return false; } private UndefinedNode(); @Override boolean isLeaf(); @Override Object accept( FilterVisitor visitor ); @Override boolean isSchemaAware(); @Override String toString(); static final UndefinedNode UNDEFINED_NODE; }### Answer: @Test public void testIsSchemaAware() throws Exception { assertFalse( undefinedNode.isSchemaAware() ); }
### Question: UndefinedNode extends AbstractExprNode { @Override public Object accept( FilterVisitor visitor ) { return null; } private UndefinedNode(); @Override boolean isLeaf(); @Override Object accept( FilterVisitor visitor ); @Override boolean isSchemaAware(); @Override String toString(); static final UndefinedNode UNDEFINED_NODE; }### Answer: @Test public void testAccept() throws Exception { assertNull( undefinedNode.accept( new FilterVisitor() { public Object visit( ExprNode node ) { return null; } public boolean isPrefix() { return false; } public List<ExprNode> getOrder( BranchNode node, List<ExprNode> children ) { return null; } public boolean canVisit( ExprNode node ) { return false; } } ) ); }
### Question: BranchNormalizedVisitor implements FilterVisitor { public static String getNormalizedFilter( SchemaManager schemaManager, String filter ) throws ParseException { ExprNode originalNode = FilterParser.parse( schemaManager, filter ); return getNormalizedFilter( originalNode ); } @Override Object visit( ExprNode node ); @Override boolean canVisit( ExprNode node ); @Override boolean isPrefix(); @Override List<ExprNode> getOrder( BranchNode node, List<ExprNode> children ); static String getNormalizedFilter( SchemaManager schemaManager, String filter ); static String getNormalizedFilter( ExprNode filter ); }### Answer: @Test public void testBranchNormalizedComplex() throws Exception { String filter1 = "(&(a=A)(\|(b=B)(c=C)))"; String filter2 = "(&(a=A)(\|(c=C)(b=B)))"; String normalizedFilter1 = BranchNormalizedVisitor.getNormalizedFilter( null, filter1 ); String normalizedFilter2 = BranchNormalizedVisitor.getNormalizedFilter( null, filter2 ); assertEquals( normalizedFilter1, normalizedFilter2 ); }
### Question: CsnFactory { public Csn newInstance() { int tmpChangeCount; synchronized ( lock ) { long newTimestamp = System.currentTimeMillis(); if ( lastTimestamp == newTimestamp ) { changeCount++; } else { lastTimestamp = newTimestamp; changeCount = 0; } tmpChangeCount = changeCount; } return new Csn( lastTimestamp, tmpChangeCount, replicaId, 0 ); } CsnFactory( int replicaId ); Csn newInstance(); Csn newInstance( long timestamp, int changeCount ); Csn newPurgeCsn( long expirationDate ); void setReplicaId( int replicaId ); }### Answer: @Test public void testUnique() { int replicaId = 001; CsnFactory defaultCSNFactory = new CsnFactory( replicaId ); Csn[] csns = new Csn[NUM_GENERATES]; for ( int i = 0; i < NUM_GENERATES; i++ ) { csns[i] = defaultCSNFactory.newInstance(); } for ( int i = 0; i < NUM_GENERATES; i++ ) { for ( int j = i + 1; j < NUM_GENERATES; j++ ) { assertFalse( csns[i].equals( csns[j] ) ); } } }
### Question: Csn implements Comparable<Csn> { public Csn( long timestamp, int changeCount, int replicaId, int operationNumber ) { this.timestamp = timestamp; this.replicaId = replicaId; this.operationNumber = operationNumber; this.changeCount = changeCount; sdf.setTimeZone( UTC_TIME_ZONE ); } Csn( long timestamp, int changeCount, int replicaId, int operationNumber ); Csn( String value ); Csn( byte[] value ); static boolean isValid( String value ); byte[] getBytes(); long getTimestamp(); int getChangeCount(); int getReplicaId(); int getOperationNumber(); @Override String toString(); @Override int hashCode(); @Override boolean equals( Object o ); @Override int compareTo( Csn csn ); }### Answer: @Test public void testCSN() { synchronized ( SDF ) { long ts = System.currentTimeMillis(); Csn csn = new Csn( SDF.format( new Date( ts ) ) + "#123456#abc#654321" ); assertEquals( ts / 1000, csn.getTimestamp() / 1000 ); assertEquals( 1193046, csn.getChangeCount() ); assertEquals( 6636321, csn.getOperationNumber() ); assertEquals( 2748, csn.getReplicaId() ); } }
### Question: CsnSidComparator extends LdapComparator<String> { public int compare( String sidStr1, String sidStr2 ) { if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13744_COMPARING_CSN_SID, sidStr1, sidStr2 ) ); } if ( sidStr1 == null ) { return ( sidStr2 == null ) ? 0 : -1; } if ( sidStr2 == null ) { return 1; } int sid1 = 0; int sid2; try { sid1 = Integer.parseInt( sidStr1, 16 ); } catch ( NumberFormatException nfe ) { return -1; } try { sid2 = Integer.parseInt( sidStr2, 16 ); } catch ( NumberFormatException nfe ) { return 1; } if ( sid1 > sid2 ) { return 1; } else if ( sid2 > sid1 ) { return -1; } return 0; } CsnSidComparator( String oid ); int compare( String sidStr1, String sidStr2 ); }### Answer: @Test public void testNullSids() { assertEquals( 0, comparator.compare( null, null ) ); assertEquals( -1, comparator.compare( null, "000" ) ); assertEquals( 1, comparator.compare( "000", null ) ); } @Test public void testEqualsSids() { assertEquals( 0, comparator.compare( "000", "000" ) ); assertEquals( 0, comparator.compare( "000", "0" ) ); assertEquals( 0, comparator.compare( "fff", "fff" ) ); } @Test public void testDifferentSids() { assertEquals( -1, comparator.compare( "123", "456" ) ); assertEquals( 1, comparator.compare( "FFF", "000" ) ); assertEquals( 1, comparator.compare( "FFF", "GGG" ) ); }
### Question: BooleanComparator extends LdapComparator<String> { public int compare( String b1, String b2 ) { if ( LOG.isDebugEnabled() ) { LOG.debug( I18n.msg( I18n.MSG_13752_COMPARING_BOOLEAN, b1, b2 ) ); } if ( b1 == b2 ) { return 0; } if ( ( b1 == null ) \|\| ( b2 == null ) ) { return b1 == null ? -1 : 1; } boolean boolean1 = Boolean.parseBoolean( b1 ); boolean boolean2 = Boolean.parseBoolean( b2 ); if ( boolean1 == boolean2 ) { return 0; } return boolean1 ? 1 : -1; } BooleanComparator( String oid ); int compare( String b1, String b2 ); }### Answer: @Test public void testNullBooleans() { assertEquals( 0, comparator.compare( null, null ) ); assertEquals( -1, comparator.compare( null, "TRUE" ) ); assertEquals( -1, comparator.compare( null, "FALSE" ) ); assertEquals( 1, comparator.compare( "TRUE", null ) ); assertEquals( 1, comparator.compare( "FALSE", null ) ); } @Test public void testBooleans() { assertEquals( 0, comparator.compare( "TRUE", "TRUE" ) ); assertEquals( 0, comparator.compare( "FALSE", "FALSE" ) ); assertEquals( -1, comparator.compare( "FALSE", "TRUE" ) ); assertEquals( 1, comparator.compare( "TRUE", "FALSE" ) ); String b1 = "TRUE"; String b2 = "true"; assertEquals( 0, comparator.compare( b1, Strings.upperCase( b2 ) ) ); }
### Question: GeneralizedTime implements Comparable<GeneralizedTime> { @Override public boolean equals( Object obj ) { if ( obj instanceof GeneralizedTime ) { GeneralizedTime other = ( GeneralizedTime ) obj; return calendar.equals( other.calendar ); } else { return false; } } GeneralizedTime( Date date ); GeneralizedTime( Calendar calendar ); GeneralizedTime( long timeInMillis ); GeneralizedTime( String generalizedTime ); String toGeneralizedTime(); String toGeneralizedTimeWithoutFraction(); String toGeneralizedTime( Format format, FractionDelimiter fractionDelimiter, int fractionLength, TimeZoneFormat timeZoneFormat ); Calendar getCalendar(); @Override String toString(); @Override int hashCode(); @Override boolean equals( Object obj ); @Override int compareTo( GeneralizedTime other ); long getTime(); Date getDate(); int getYear(); int getMonth(); int getDay(); int getHour(); int getMinutes(); int getSeconds(); int getFraction(); static Date getDate( String zuluTime ); }### Answer: @Test public void testEquals() throws ParseException { String gt1 = "20080102121314Z"; GeneralizedTime generalizedTime1 = new GeneralizedTime( gt1 ); String gt2 = "20080102121314Z"; GeneralizedTime generalizedTime2 = new GeneralizedTime( gt2 ); String gt3 = "20080102121314,001Z"; GeneralizedTime generalizedTime3 = new GeneralizedTime( gt3 ); assertTrue( generalizedTime1.equals( generalizedTime2 ) ); assertFalse( generalizedTime1.equals( generalizedTime3 ) ); assertFalse( generalizedTime1.equals( null ) ); }
### Question: NameForm extends AbstractSchemaObject { @Override public String toString() { return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this ); } NameForm( String oid ); String getStructuralObjectClassOid(); ObjectClass getStructuralObjectClass(); void setStructuralObjectClassOid( String structuralObjectClassOid ); void setStructuralObjectClass( ObjectClass structuralObjectClass ); List<String> getMustAttributeTypeOids(); List<AttributeType> getMustAttributeTypes(); void setMustAttributeTypeOids( List<String> mustAttributeTypeOids ); void setMustAttributeTypes( List<AttributeType> mustAttributeTypes ); void addMustAttributeTypeOids( String oid ); void addMustAttributeTypes( AttributeType attributeType ); List<String> getMayAttributeTypeOids(); List<AttributeType> getMayAttributeTypes(); void setMayAttributeTypeOids( List<String> mayAttributeTypeOids ); void setMayAttributeTypes( List<AttributeType> mayAttributeTypes ); void addMayAttributeTypeOids( String oid ); void addMayAttributeTypes( AttributeType attributeType ); @Override String toString(); @Override NameForm copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; }### Answer: @Test public void testToString() throws Exception { String string = nameForm.toString(); assertNotNull( string ); assertTrue( string.startsWith( "nameform (" ) ); assertTrue( string.contains( " NAME " ) ); assertTrue( string.contains( "\n\tDESC " ) ); assertTrue( string.contains( "\n\tOC" ) ); assertTrue( string.contains( "\n\tMUST" ) ); assertTrue( string.contains( "\n\tMAY" ) ); }
### Question: MatchingRule extends AbstractSchemaObject { @Override public String toString() { return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this ); } MatchingRule( String oid ); LdapSyntax getSyntax(); void setSyntax( LdapSyntax ldapSyntax ); String getSyntaxOid(); void setSyntaxOid( String oid ); LdapComparator<? super Object> getLdapComparator(); @SuppressWarnings("unchecked") void setLdapComparator( LdapComparator<?> ldapComparator ); Normalizer getNormalizer(); void setNormalizer( Normalizer normalizer ); @Override String toString(); @Override MatchingRule copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; }### Answer: @Test public void testToString() throws Exception { String string = matchingRule.toString(); assertNotNull( string ); assertTrue( string.startsWith( "matchingrule (" ) ); assertTrue( string.contains( " NAME " ) ); assertTrue( string.contains( "\n\tDESC " ) ); assertTrue( string.contains( "\n\tSYNTAX " ) ); }
### Question: LdapSyntax extends AbstractSchemaObject { @Override public String toString() { return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this ); } LdapSyntax( String oid ); LdapSyntax( String oid, String description ); LdapSyntax( String oid, String description, boolean isHumanReadable ); boolean isHumanReadable(); void setHumanReadable( boolean humanReadable ); SyntaxChecker getSyntaxChecker(); void setSyntaxChecker( SyntaxChecker syntaxChecker ); void updateSyntaxChecker( SyntaxChecker newSyntaxChecker ); @Override String toString(); @Override LdapSyntax copy(); @Override int hashCode(); @Override boolean equals( Object o ); @Override void clear(); static final long serialVersionUID; }### Answer: @Test public void testToString() throws Exception { String string = ldapSyntax.toString(); assertNotNull( string ); assertTrue( string.startsWith( "ldapsyntax (" ) ); assertTrue( string.contains( "\n\tDESC " ) ); assertTrue( string.contains( "\n\tX-NOT-HUMAN-READABLE " ) ); }

Subsets and Splits