method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
SendMessageProcessor extends AbstractSendMessageProcessor implements NettyRequestProcessor { @Override public RemotingCommand processRequest(ChannelHandlerContext ctx, RemotingCommand request) throws RemotingCommandException { SendMessageContext mqtraceContext; switch (request.getCode()) { case RequestCode.CONSUMER_SEND_MSG_BACK: return this.consumerSendMsgBack(ctx, request); default: SendMessageRequestHeader requestHeader = parseRequestHeader(request); if (requestHeader == null) { return null; } mqtraceContext = buildMsgContext(ctx, requestHeader); this.executeSendMessageHookBefore(ctx, request, mqtraceContext); final RemotingCommand response = this.sendMessage(ctx, request, mqtraceContext, requestHeader); this.executeSendMessageHookAfter(response, mqtraceContext); return response; } } SendMessageProcessor(final BrokerController brokerController); @Override RemotingCommand processRequest(ChannelHandlerContext ctx, RemotingCommand request); @Override boolean rejectRequest(); boolean hasConsumeMessageHook(); void executeConsumeMessageHookAfter(final ConsumeMessageContext context); SocketAddress getStoreHost(); void registerConsumeMessageHook(List<ConsumeMessageHook> consumeMessageHookList); }### Answer:
@Test public void testProcessRequest() throws RemotingCommandException { when(messageStore.putMessage(any(MessageExtBrokerInner.class))).thenReturn(new PutMessageResult(PutMessageStatus.PUT_OK, new AppendMessageResult(AppendMessageStatus.PUT_OK))); assertPutResult(ResponseCode.SUCCESS); }
@Test public void testProcessRequest_WithMsgBack() throws RemotingCommandException { when(messageStore.putMessage(any(MessageExtBrokerInner.class))).thenReturn(new PutMessageResult(PutMessageStatus.PUT_OK, new AppendMessageResult(AppendMessageStatus.PUT_OK))); final RemotingCommand request = createSendMsgBackCommand(RequestCode.CONSUMER_SEND_MSG_BACK); sendMessageProcessor = new SendMessageProcessor(brokerController); final RemotingCommand response = sendMessageProcessor.processRequest(handlerContext, request); assertThat(response).isNotNull(); assertThat(response.getCode()).isEqualTo(ResponseCode.SUCCESS); }
|
### Question:
ClientManageProcessor implements NettyRequestProcessor { @Override public RemotingCommand processRequest(ChannelHandlerContext ctx, RemotingCommand request) throws RemotingCommandException { switch (request.getCode()) { case RequestCode.HEART_BEAT: return this.heartBeat(ctx, request); case RequestCode.UNREGISTER_CLIENT: return this.unregisterClient(ctx, request); default: break; } return null; } ClientManageProcessor(final BrokerController brokerController); @Override RemotingCommand processRequest(ChannelHandlerContext ctx, RemotingCommand request); @Override boolean rejectRequest(); RemotingCommand heartBeat(ChannelHandlerContext ctx, RemotingCommand request); RemotingCommand unregisterClient(ChannelHandlerContext ctx, RemotingCommand request); }### Answer:
@Test public void processRequest_UnRegisterProducer() throws Exception { brokerController.getProducerManager().registerProducer(group, clientChannelInfo); HashMap<Channel, ClientChannelInfo> channelMap = brokerController.getProducerManager().getGroupChannelTable().get(group); assertThat(channelMap).isNotNull(); assertThat(channelMap.get(channel)).isEqualTo(clientChannelInfo); RemotingCommand request = createUnRegisterProducerCommand(); RemotingCommand response = clientManageProcessor.processRequest(handlerContext, request); assertThat(response).isNotNull(); assertThat(response.getCode()).isEqualTo(ResponseCode.SUCCESS); channelMap = brokerController.getProducerManager().getGroupChannelTable().get(group); assertThat(channelMap).isNull(); }
@Test public void processRequest_UnRegisterConsumer() throws RemotingCommandException { ConsumerGroupInfo consumerGroupInfo = brokerController.getConsumerManager().getConsumerGroupInfo(group); assertThat(consumerGroupInfo).isNotNull(); RemotingCommand request = createUnRegisterConsumerCommand(); RemotingCommand response = clientManageProcessor.processRequest(handlerContext, request); assertThat(response).isNotNull(); assertThat(response.getCode()).isEqualTo(ResponseCode.SUCCESS); consumerGroupInfo = brokerController.getConsumerManager().getConsumerGroupInfo(group); assertThat(consumerGroupInfo).isNull(); }
|
### Question:
FilterAPI { public static SubscriptionData buildSubscriptionData(final String consumerGroup, String topic, String subString) throws Exception { SubscriptionData subscriptionData = new SubscriptionData(); subscriptionData.setTopic(topic); subscriptionData.setSubString(subString); if (null == subString || subString.equals(SubscriptionData.SUB_ALL) || subString.length() == 0) { subscriptionData.setSubString(SubscriptionData.SUB_ALL); } else { String[] tags = subString.split("\\|\\|"); if (tags.length > 0) { for (String tag : tags) { if (tag.length() > 0) { String trimString = tag.trim(); if (trimString.length() > 0) { subscriptionData.getTagsSet().add(trimString); subscriptionData.getCodeSet().add(trimString.hashCode()); } } } } else { throw new Exception("subString split error"); } } return subscriptionData; } static URL classFile(final String className); static String simpleClassName(final String className); static SubscriptionData buildSubscriptionData(final String consumerGroup, String topic,
String subString); }### Answer:
@Test public void testBuildSubscriptionData() throws Exception { SubscriptionData subscriptionData = FilterAPI.buildSubscriptionData(group, topic, subString); assertThat(subscriptionData.getTopic()).isEqualTo(topic); assertThat(subscriptionData.getSubString()).isEqualTo(subString); String [] tags = subString.split("\\|\\|"); Set<String> tagSet = new HashSet<>(); for (String tag : tags) { tagSet.add(tag.trim()); } assertThat(subscriptionData.getTagsSet()).isEqualTo(tagSet); }
|
### Question:
UtilAll { public static int getPid() { RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean(); String name = runtime.getName(); try { return Integer.parseInt(name.substring(0, name.indexOf('@'))); } catch (Exception e) { return -1; } } static int getPid(); static String currentStackTrace(); static String offset2FileName(final long offset); static long computeEclipseTimeMilliseconds(final long beginTime); static boolean isItTimeToDo(final String when); static String timeMillisToHumanString(); static String timeMillisToHumanString(final long t); static long computNextMorningTimeMillis(); static long computNextMinutesTimeMillis(); static long computNextHourTimeMillis(); static long computNextHalfHourTimeMillis(); static String timeMillisToHumanString2(final long t); static String timeMillisToHumanString3(final long t); static double getDiskPartitionSpaceUsedPercent(final String path); static int crc32(byte[] array); static int crc32(byte[] array, int offset, int length); static String bytes2string(byte[] src); static byte[] string2bytes(String hexString); static byte[] uncompress(final byte[] src); static byte[] compress(final byte[] src, final int level); static int asInt(String str, int defaultValue); static long asLong(String str, long defaultValue); static String formatDate(Date date, String pattern); static Date parseDate(String date, String pattern); static String responseCode2String(final int code); static String frontStringAtLeast(final String str, final int size); static boolean isBlank(String str); static String jstack(); static String jstack(Map<Thread, StackTraceElement[]> map); static boolean isInternalIP(byte[] ip); static String ipToIPv4Str(byte[] ip); static byte[] getIP(); static final String YYYY_MM_DD_HH_MM_SS; static final String YYYY_MM_DD_HH_MM_SS_SSS; static final String YYYY_MMDD_HHMMSS; }### Answer:
@Test public void testGetPid() { assertThat(UtilAll.getPid()).isGreaterThan(0); }
|
### Question:
ProducerConnectionSubCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { defaultMQAdminExt.start(); String group = commandLine.getOptionValue('g').trim(); String topic = commandLine.getOptionValue('t').trim(); ProducerConnection pc = defaultMQAdminExt.examineProducerConnectionInfo(group, topic); int i = 1; for (Connection conn : pc.getConnectionSet()) { System.out.printf("%04d %-32s %-22s %-8s %s%n", i++, conn.getClientId(), conn.getClientAddr(), conn.getLanguage(), MQVersion.getVersionDesc(conn.getVersion()) ); } } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { ProducerConnectionSubCommand cmd = new ProducerConnectionSubCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-g default-producer-group", "-t unit-test"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); cmd.execute(commandLine, options, null); }
|
### Question:
SelectMessageQueueByHash implements MessageQueueSelector { @Override public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) { int value = arg.hashCode(); if (value < 0) { value = Math.abs(value); } value = value % mqs.size(); return mqs.get(value); } @Override MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg); }### Answer:
@Test public void testSelect() throws Exception { SelectMessageQueueByHash selector = new SelectMessageQueueByHash(); Message message = new Message(topic, new byte[] {}); List<MessageQueue> messageQueues = new ArrayList<>(); for (int i = 0; i < 10; i++) { MessageQueue messageQueue = new MessageQueue(topic, "DefaultBroker", i); messageQueues.add(messageQueue); } String orderId = "123"; String anotherOrderId = "234"; MessageQueue selected = selector.select(messageQueues, message, orderId); assertThat(selector.select(messageQueues, message, anotherOrderId)).isNotEqualTo(selected); }
@Test public void testSelect() throws Exception { SelectMessageQueueByHash selector = new SelectMessageQueueByHash(); Message message = new Message(topic, new byte[] {}); List<MessageQueue> messageQueues = new ArrayList<MessageQueue>(); for (int i = 0; i < 10; i++) { MessageQueue messageQueue = new MessageQueue(topic, "DefaultBroker", i); messageQueues.add(messageQueue); } String orderId = "123"; String anotherOrderId = "234"; MessageQueue selected = selector.select(messageQueues, message, orderId); assertThat(selector.select(messageQueues, message, anotherOrderId)).isNotEqualTo(selected); }
|
### Question:
ChecksumHelper { protected byte[] addChecksum(byte[] source) { CRC32 crc32 = new CRC32(); crc32.update(source); long checkSum = crc32.getValue(); byte[] checkSumBytes = String.valueOf(checkSum).getBytes(); byte[] concat = Bytes.concat(source, (SEPARATOR+"").getBytes(), checkSumBytes); return concat; } }### Answer:
@Test public void testAddChecksum() { ChecksumHelper checksumHelper = new ChecksumHelper(); byte[] source = "foobarbaz".getBytes(); log.debug("source : " + new String(source)); byte[] withChecksum = checksumHelper.addChecksum(source); log.debug("withChecksum: " + new String(withChecksum)); assertEquals("foobarbaz#444082090", new String(withChecksum)); }
|
### Question:
Compressor { public byte[] compress(byte[] source) throws IOException { return compress(DEFAULTCOMPRESSIONTYPE, source); } byte[] compress(byte[] source); byte[] compress(CompressionType type, byte[] source); byte[] decompress(byte[] source); byte[] decompress(CompressionType type, byte[] source); }### Answer:
@Test public void testCompressionDoesCompress() throws IOException { Compressor compressor = new Compressor(); String uncompressed = "foobarbazamassivelylongstringofsomethingthatshouldcompressprettyfineeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; log.info("uncompressed: " + uncompressed); byte[] compressed = compressor.compress(uncompressed.getBytes()); log.info("compressed: " + new String(compressed)); assertTrue(compressed.length <= uncompressed.length()); }
|
### Question:
ExtrasHandler { void addToExtras(List<Person> persons) { persons.forEach(p -> { p.setRelationshipStatus(null); p.clearFamilyID(); }); this.extras.addAll(persons); persons.clear(); } ExtrasHandler(List<IndRecord> indRecords, Random random); }### Answer:
@Test public void testAddToExtras() throws NoSuchFieldException, IllegalAccessException { int startingSize = extrasHandler.remainingExtras(); Person p = new Person(); p.setRelationshipStatus(RelationshipStatus.RELATIVE); p.setAgeRange(AgeRange.A25_39); p.setSex(Sex.Male); extrasHandler.addToExtras(new ArrayList<>(Collections.singleton(p))); Assert.assertTrue("New person added to extras - extras increments by one", startingSize + 1 == extrasHandler.remainingExtras()); Field field = ExtrasHandler.class.getDeclaredField("extras"); field.setAccessible(true); List<Person> extras = (List<Person>) field.get(extrasHandler); Person lastAddedToExtras = extras.get(extras.size() - 1); Assert.assertEquals("New person added to extra - age", lastAddedToExtras.getAgeRange(), AgeRange.A25_39); Assert.assertEquals("New person added to extra - sex", lastAddedToExtras.getSex(), Sex.Male); Assert.assertEquals("New person added to extra - relationship status", lastAddedToExtras.getRelationshipStatus(), null); }
|
### Question:
ExtrasHandler { int remainingExtras() { return extras.size(); } ExtrasHandler(List<IndRecord> indRecords, Random random); }### Answer:
@Test public void testFormingExtras() { Assert.assertNotNull(extrasHandler); Assert.assertEquals("Number of extras", extrasHandler.remainingExtras(), 145); }
|
### Question:
CacheLoaderAdapter implements CacheLoader<K, V>, Factory<CacheLoader<K, V>> { @Override public Map<K, V> loadAll(final Iterable<? extends K> keys) throws CacheLoaderException { final Map<K, V> result = new HashMap<K, V>(); for (final K k : keys) { final V v = load(k); if (v != null) { result.put(k, v); } } return result; } @Override Map<K, V> loadAll(final Iterable<? extends K> keys); @Override CacheLoader<K, V> create(); }### Answer:
@Test public void checkLoadAll() { assertFalse(cache.iterator().hasNext()); assertEquals("foo", cache.get("foo")); count.decrementAndGet(); cache.loadAll(new HashSet<String>(asList("a", "b")), true, null); int retries = 100; while (retries-- > 0 && count.get() != 2) { try { Thread.sleep(20); } catch (final InterruptedException e) { Thread.interrupted(); } } assertEquals(2, count.get()); assertEquals("a", cache.get("a")); assertEquals("b", cache.get("b")); assertEquals(2, count.get()); }
|
### Question:
CDIJCacheHelper { public MethodMeta findMeta(final InvocationContext ic) { final Method mtd = ic.getMethod(); final Class<?> refType = findKeyType(ic.getTarget()); final MethodKey key = new MethodKey(refType, mtd); MethodMeta methodMeta = methods.get(key); if (methodMeta == null) { synchronized (this) { methodMeta = methods.get(key); if (methodMeta == null) { methodMeta = createMeta(ic); methods.put(key, methodMeta); } } } return methodMeta; } MethodMeta findMeta(final InvocationContext ic); boolean isIncluded(final Class<?> aClass, final Class<?>[] in, final Class<?>[] out); }### Answer:
@Test public void proxyCacheDefaults() { final CDIJCacheHelper helper = new CDIJCacheHelper(); final MyParent child1 = MyParent.class.cast(Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class<?>[]{MyChild1.class}, (proxy, method, args) -> null)); final CDIJCacheHelper.MethodMeta meta1 = helper.findMeta(newContext(child1)); assertEquals("child", meta1.getCacheResultCacheName()); final MyParent child2 = MyParent.class.cast(Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class<?>[]{MyChild2.class}, (proxy, method, args) -> null)); final CDIJCacheHelper.MethodMeta meta2 = helper.findMeta(newContext(child2)); assertEquals("child2", meta2.getCacheResultCacheName()); }
|
### Question:
DelegatingInvoker implements Invoker { @Override public Object invoke(Object proxy, Method method, Object[] arguments) throws Throwable { try { return method.invoke(delegateProvider.getObject(), arguments); } catch (InvocationTargetException e) { throw e.getTargetException(); } } DelegatingInvoker(ObjectProvider<? extends T> delegateProvider); @Override Object invoke(Object proxy, Method method, Object[] arguments); }### Answer:
@Test public void test() throws Throwable { final Invoker invoker = new DelegatingInvoker<Echo>(ObjectProviderUtils.constant(new EchoImpl())); assertEquals("foo", invoker.invoke(null, Echo.class.getDeclaredMethod("echoBack", String.class), new Object[] { "foo" })); }
|
### Question:
CloningProvider implements ObjectProvider<T>, Serializable { @Override public T getObject() { try { return ObjectUtils.clone(cloneable); } catch (CloneFailedException e) { throw new ObjectProviderException(e.getMessage(), e.getCause()); } } CloningProvider(T cloneable); @Override T getObject(); }### Answer:
@Test public void testValidCloneable() { final Date now = new Date(); final CloningProvider<Date> provider = new CloningProvider<Date>(now); final Date clone1 = provider.getObject(); assertEquals(now, clone1); assertNotSame(now, clone1); final Date clone2 = provider.getObject(); assertEquals(now, clone2); assertNotSame(now, clone2); assertNotSame(clone2, clone1); }
@Test public void testWithExceptionThrown() { final CloningProvider<ExceptionCloneable> provider = new CloningProvider<ExceptionCloneable>( new ExceptionCloneable()); try { provider.getObject(); fail(); } catch (ObjectProviderException e) { } }
@Test(expected = IllegalArgumentException.class) public void testWithProtectedCloneMethod() { final CloningProvider<ProtectedCloneable> provider = new CloningProvider<ProtectedCloneable>( new ProtectedCloneable()); provider.getObject(); }
|
### Question:
InterceptorUtils { public static Interceptor constant(Object value) { return new ObjectProviderInterceptor(ObjectProviderUtils.constant(value)); } private InterceptorUtils(); static Interceptor constant(Object value); static Interceptor provider(ObjectProvider<?> provider); static Interceptor throwing(Exception e); static Interceptor throwing(ObjectProvider<? extends Exception> provider); static Interceptor invoking(Invoker invoker); }### Answer:
@Test public void testConstant() throws Throwable { Interceptor interceptor = InterceptorUtils.constant("Hello!"); Invocation invocation = mockInvocation(Echo.class, "echoBack", String.class).withArguments("World!").build(); assertEquals("Hello!", interceptor.intercept(invocation)); }
|
### Question:
InterceptorUtils { public static Interceptor provider(ObjectProvider<?> provider) { return new ObjectProviderInterceptor(provider); } private InterceptorUtils(); static Interceptor constant(Object value); static Interceptor provider(ObjectProvider<?> provider); static Interceptor throwing(Exception e); static Interceptor throwing(ObjectProvider<? extends Exception> provider); static Interceptor invoking(Invoker invoker); }### Answer:
@Test public void testProvider() throws Throwable { Interceptor interceptor = InterceptorUtils.provider(ObjectProviderUtils.constant("Foo!")); Invocation invocation = mockInvocation(Echo.class, "echoBack", String.class).withArguments("World!").build(); assertEquals("Foo!", interceptor.intercept(invocation)); }
|
### Question:
InterceptorUtils { public static Interceptor throwing(Exception e) { return new ThrowingInterceptor(ObjectProviderUtils.constant(e)); } private InterceptorUtils(); static Interceptor constant(Object value); static Interceptor provider(ObjectProvider<?> provider); static Interceptor throwing(Exception e); static Interceptor throwing(ObjectProvider<? extends Exception> provider); static Interceptor invoking(Invoker invoker); }### Answer:
@Test(expected = RuntimeException.class) public void testThrowingExceptionObject() throws Throwable { Interceptor interceptor = InterceptorUtils.throwing(new RuntimeException("Oops!")); Invocation invocation = mockInvocation(Echo.class, "echoBack", String.class).withArguments("World!").build(); interceptor.intercept(invocation); }
|
### Question:
ObjectProviderInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { return provider.getObject(); } ObjectProviderInterceptor(ObjectProvider<?> provider); @Override Object intercept(Invocation invocation); }### Answer:
@Test public void testIntercept() throws Throwable { ObjectProviderInterceptor interceptor = new ObjectProviderInterceptor(ObjectProviderUtils.constant("Hello!")); assertEquals("Hello!", interceptor.intercept(null)); }
|
### Question:
SwitchInterceptor implements Interceptor, Serializable { @Override public Object intercept(Invocation invocation) throws Throwable { for (Pair<InvocationMatcher, Interceptor> currentCase : cases) { if (currentCase.getLeft().matches(invocation)) { return currentCase.getRight().intercept(invocation); } } return invocation.proceed(); } SwitchInterceptor(); @Override Object intercept(Invocation invocation); CaseBuilder when(InvocationMatcher matcher); }### Answer:
@Test public void testWithNoAdvice() throws Throwable { SwitchInterceptor interceptor = new SwitchInterceptor(); Method method = Echo.class.getMethod("echoBack", String.class); Invocation invocation = new MockInvocation(method, "foo", "foo"); assertEquals("foo", interceptor.intercept(invocation)); }
|
### Question:
InvokerInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { return invoker.invoke(invocation.getProxy(), invocation.getMethod(), invocation.getArguments()); } InvokerInterceptor(Invoker invoker); @Override Object intercept(Invocation invocation); }### Answer:
@Test public void testIntercept() throws Throwable { final InvokerInterceptor interceptor = new InvokerInterceptor(new Invoker() { private static final long serialVersionUID = 1L; @Override public Object invoke(Object proxy, Method method, Object[] arguments) throws Throwable { return "Hello!"; } }); final Invocation invocation = new MockInvocationBuilder(Echo.class.getDeclaredMethod("echoBack", String.class)) .withArguments("foo").build(); assertEquals("Hello!", interceptor.intercept(invocation)); }
|
### Question:
ArgumentMatcherUtils { public static <T> ArgumentMatcher<T> any() { return new AnyMatcher<T>(); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testAny() throws Exception { ArgumentMatcher<Object> matcher = ArgumentMatcherUtils.any(); assertTrue(matcher.matches(null)); assertTrue(matcher.matches("Hello!")); assertTrue(matcher.matches(12345)); }
|
### Question:
BeanProvider implements ObjectProvider<T>, Serializable { @Override public T getObject() { try { return beanClass.newInstance(); } catch (InstantiationException e) { throw new ObjectProviderException(e, "%s is not concrete.", beanClass); } catch (IllegalAccessException e) { throw new ObjectProviderException(e, "Constructor for %s is not accessible.", beanClass); } } BeanProvider(Class<? extends T> beanClass); @Override T getObject(); }### Answer:
@Test(expected = ObjectProviderException.class) public void testAbstractBeanClass() { final BeanProvider<Number> p = new BeanProvider<Number>(Number.class); p.getObject(); }
@Test(expected = ObjectProviderException.class) public void testNonAccessibleConstructor() { new BeanProvider<MyBean>(MyBean.class).getObject(); }
@Test(expected = NullPointerException.class) public void testWithNullBeanClass() { final BeanProvider<Object> p = new BeanProvider<Object>(null); p.getObject(); }
|
### Question:
ArgumentMatcherUtils { public static <T> ArgumentMatcher<T> eq(final T value) { return new EqualsMatcher<T>(value); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testEq() throws Exception { ArgumentMatcher<String> matcher = ArgumentMatcherUtils.eq("Hello"); assertTrue(matcher.matches("Hello")); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static <C extends Comparable<C>> ArgumentMatcher<C> gt(C comparable) { return new GreaterThanMatcher<C>(comparable); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testGt() throws Exception { ArgumentMatcher<Integer> matcher = ArgumentMatcherUtils.gt(5); assertTrue(matcher.matches(6)); assertFalse(matcher.matches(5)); assertFalse(matcher.matches(1)); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static <C extends Comparable<C>> ArgumentMatcher<C> gte(C comparable) { return new GreaterThanOrEqualMatcher<C>(comparable); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testGte() throws Exception { ArgumentMatcher<Integer> matcher = ArgumentMatcherUtils.gte(5); assertTrue(matcher.matches(6)); assertTrue(matcher.matches(5)); assertFalse(matcher.matches(1)); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static <T> ArgumentMatcher<T> isA(final Class<?> type) { return new InstanceOfMatcher<T>(type); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testIsA() throws Exception { ArgumentMatcher<Object> matcher = ArgumentMatcherUtils.isA(String.class); assertFalse(matcher.matches(null)); assertTrue(matcher.matches("Hello")); assertFalse(matcher.matches(123)); }
|
### Question:
ArgumentMatcherUtils { public static <T> ArgumentMatcher<T> isNull() { return new IsNullMatcher<T>(); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testIsNull() throws Exception { ArgumentMatcher<Object> matcher = ArgumentMatcherUtils.isNull(); assertTrue(matcher.matches(null)); assertFalse(matcher.matches("Hello")); assertFalse(matcher.matches(123)); }
|
### Question:
ArgumentMatcherUtils { public static <C extends Comparable<C>> ArgumentMatcher<C> lt(C comparable) { return new LessThanMatcher<C>(comparable); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testLt() throws Exception { ArgumentMatcher<Integer> matcher = ArgumentMatcherUtils.lt(5); assertTrue(matcher.matches(4)); assertFalse(matcher.matches(5)); assertFalse(matcher.matches(19)); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static <C extends Comparable<C>> ArgumentMatcher<C> lte(C comparable) { return new LessThanOrEqualMatcher<C>(comparable); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testLte() throws Exception { ArgumentMatcher<Integer> matcher = ArgumentMatcherUtils.lte(5); assertTrue(matcher.matches(4)); assertTrue(matcher.matches(5)); assertFalse(matcher.matches(19)); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static ArgumentMatcher<String> matches(String regex) { return new RegexMatcher(Validate.notNull(regex)); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testMatches() throws Exception { ArgumentMatcher<String> matcher = ArgumentMatcherUtils.matches("(abc)+"); assertTrue(matcher.matches("abc")); assertTrue(matcher.matches("abcabc")); assertFalse(matcher.matches("")); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static <T> ArgumentMatcher<T> notNull() { return new NotNullMatcher<T>(); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testNotNull() throws Exception { ArgumentMatcher<String> matcher = ArgumentMatcherUtils.notNull(); assertTrue(matcher.matches("Hello")); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static ArgumentMatcher<String> startsWith(String prefix) { return new StartsWithMatcher(Validate.notNull(prefix)); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testStartsWith() throws Exception { ArgumentMatcher<String> matcher = ArgumentMatcherUtils.startsWith("abc"); assertTrue(matcher.matches("abc")); assertTrue(matcher.matches("abcd")); assertFalse(matcher.matches("ab")); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static ArgumentMatcher<String> endsWith(String suffix) { return new EndsWithMatcher(Validate.notNull(suffix)); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testEndsWith() throws Exception { ArgumentMatcher<String> matcher = ArgumentMatcherUtils.endsWith("abc"); assertTrue(matcher.matches("abc")); assertTrue(matcher.matches("dabc")); assertFalse(matcher.matches("ab")); assertFalse(matcher.matches(null)); }
|
### Question:
ProxyUtils { public static <T> T nullValue(Class<T> type) { @SuppressWarnings("unchecked") final T result = (T) NULL_VALUE_MAP.get(type); return result; } private ProxyUtils(); static Class<?>[] getAllInterfaces(Class<?> cls); static String getJavaClassName(Class<?> clazz); static Class<?> getWrapperClass(Class<?> primitiveType); static T nullValue(Class<T> type); static boolean isEqualsMethod(Method method); static boolean isHashCode(Method method); static ProxyFactory proxyFactory(); static final Object[] EMPTY_ARGUMENTS; static final Class<?>[] EMPTY_ARGUMENT_TYPES; }### Answer:
@Test public void testNullValue() { assertNullValue(null, String.class); assertNullValue(Character.valueOf((char) 0), Character.TYPE); assertNullValue(Integer.valueOf(0), Integer.TYPE); assertNullValue(Long.valueOf(0), Long.TYPE); assertNullValue(Short.valueOf((short) 0), Short.TYPE); assertNullValue(Double.valueOf(0), Double.TYPE); assertNullValue(Float.valueOf(0), Float.TYPE); assertNullValue(Boolean.FALSE, Boolean.TYPE); assertNullValue(Byte.valueOf((byte) 0), Byte.TYPE); }
|
### Question:
ProxyUtils { public static Class<?>[] getAllInterfaces(Class<?> cls) { return cls == null ? null : ClassUtils.getAllInterfaces(cls).toArray(ArrayUtils.EMPTY_CLASS_ARRAY); } private ProxyUtils(); static Class<?>[] getAllInterfaces(Class<?> cls); static String getJavaClassName(Class<?> clazz); static Class<?> getWrapperClass(Class<?> primitiveType); static T nullValue(Class<T> type); static boolean isEqualsMethod(Method method); static boolean isHashCode(Method method); static ProxyFactory proxyFactory(); static final Object[] EMPTY_ARGUMENTS; static final Class<?>[] EMPTY_ARGUMENT_TYPES; }### Answer:
@Test public void testGetAllInterfaces() { assertNull(ProxyUtils.getAllInterfaces(null)); assertEquals(Arrays.asList(new Class[] { DuplicateEcho.class, Serializable.class, Echo.class }), Arrays.asList(ProxyUtils.getAllInterfaces(EchoImpl.class))); }
|
### Question:
ProxyUtils { public static String getJavaClassName(Class<?> clazz) { if (clazz.isArray()) { return getJavaClassName(clazz.getComponentType()) + "[]"; } return clazz.getName(); } private ProxyUtils(); static Class<?>[] getAllInterfaces(Class<?> cls); static String getJavaClassName(Class<?> clazz); static Class<?> getWrapperClass(Class<?> primitiveType); static T nullValue(Class<T> type); static boolean isEqualsMethod(Method method); static boolean isHashCode(Method method); static ProxyFactory proxyFactory(); static final Object[] EMPTY_ARGUMENTS; static final Class<?>[] EMPTY_ARGUMENT_TYPES; }### Answer:
@Test public void testGetJavaClassName() throws Exception { assertEquals("java.lang.Object[]", ProxyUtils.getJavaClassName(Object[].class)); assertEquals("java.lang.Object[][]", ProxyUtils.getJavaClassName(Object[][].class)); assertEquals("java.lang.String[][][]", ProxyUtils.getJavaClassName(String[][][].class)); assertEquals("int", ProxyUtils.getJavaClassName(Integer.TYPE)); assertEquals("float", ProxyUtils.getJavaClassName(Float.TYPE)); assertEquals("long", ProxyUtils.getJavaClassName(Long.TYPE)); assertEquals("double", ProxyUtils.getJavaClassName(Double.TYPE)); assertEquals("short", ProxyUtils.getJavaClassName(Short.TYPE)); assertEquals("byte", ProxyUtils.getJavaClassName(Byte.TYPE)); assertEquals("char", ProxyUtils.getJavaClassName(Character.TYPE)); assertEquals("boolean", ProxyUtils.getJavaClassName(Boolean.TYPE)); }
|
### Question:
MethodSignature implements Serializable { @Override public boolean equals(Object o) { if (o == null) { return false; } if (o == this) { return true; } if (o.getClass() != getClass()) { return false; } MethodSignature other = (MethodSignature) o; return other.internal.equals(internal); } MethodSignature(Method method); Method toMethod(Class<?> type); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { final MethodSignature sig = new MethodSignature(Echo.class.getMethod("echoBack", String.class)); assertTrue(sig.equals(sig)); assertFalse(sig.equals("echoBack")); assertEquals(sig, new MethodSignature(Echo.class.getMethod("echoBack", String.class))); assertEquals(sig, new MethodSignature(DuplicateEcho.class.getMethod("echoBack", String.class))); assertFalse(sig.equals(new MethodSignature(Echo.class.getMethod("echoBack", String.class, String.class)))); assertFalse(sig.equals(new MethodSignature(Echo.class.getMethod("echo")))); }
|
### Question:
MethodSignature implements Serializable { @Override public String toString() { return internal; } MethodSignature(Method method); Method toMethod(Class<?> type); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testToString() throws Exception { assertEquals("echo()", new MethodSignature(Echo.class.getMethod("echo")).toString()); assertEquals("echoBack(Ljava/lang/String;)", new MethodSignature(Echo.class.getMethod("echoBack", String.class)).toString()); assertEquals("echoBack([Ljava/lang/String;)", new MethodSignature(Echo.class.getMethod("echoBack", String[].class)).toString()); assertEquals("echoBack([[Ljava/lang/String;)", new MethodSignature(Echo.class.getMethod("echoBack", String[][].class)).toString()); assertEquals("echoBack([[[Ljava/lang/String;)", new MethodSignature(Echo.class.getMethod("echoBack", String[][][].class)).toString()); assertEquals("echoBack(I)", new MethodSignature(Echo.class.getMethod("echoBack", int.class)).toString()); assertEquals("echoBack(Z)", new MethodSignature(Echo.class.getMethod("echoBack", boolean.class)).toString()); assertEquals("echoBack(Ljava/lang/String;Ljava/lang/String;)", new MethodSignature(Echo.class.getMethod("echoBack", String.class, String.class)).toString()); assertEquals("illegalArgument()", new MethodSignature(Echo.class.getMethod("illegalArgument")).toString()); assertEquals("ioException()", new MethodSignature(Echo.class.getMethod("ioException")).toString()); }
|
### Question:
MethodSignature implements Serializable { public Method toMethod(Class<?> type) { final Pair<String, Class<?>[]> info = parse(internal); return MethodUtils.getAccessibleMethod(type, info.getLeft(), info.getRight()); } MethodSignature(Method method); Method toMethod(Class<?> type); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testToMethod() throws Exception { final MethodSignature sig = new MethodSignature(Echo.class.getMethod("echoBack", String.class)); assertMethodIs(sig.toMethod(Echo.class), Echo.class, "echoBack", String.class); assertMethodIs(sig.toMethod(AbstractEcho.class), AbstractEcho.class, "echoBack", String.class); assertMethodIs(sig.toMethod(EchoImpl.class), AbstractEcho.class, "echoBack", String.class); assertMethodIs(sig.toMethod(DuplicateEcho.class), DuplicateEcho.class, "echoBack", String.class); }
|
### Question:
ObjectProviderUtils { public static <T> ObjectProvider<T> bean(Class<T> beanClass) { return new BeanProvider<T>(beanClass); } private ObjectProviderUtils(); static ObjectProvider<T> bean(Class<T> beanClass); static ObjectProvider<T> cloning(T prototype); static ObjectProvider<T> constant(T value); static ObjectProvider<T> nullValue(); static ObjectProvider<T> singleton(ObjectProvider<T> inner); }### Answer:
@Test public void testBean() throws Exception { assertTrue(ObjectProviderUtils.bean(EchoImpl.class) instanceof BeanProvider); }
|
### Question:
ObjectProviderUtils { public static <T extends Cloneable> ObjectProvider<T> cloning(T prototype) { return new CloningProvider<T>(prototype); } private ObjectProviderUtils(); static ObjectProvider<T> bean(Class<T> beanClass); static ObjectProvider<T> cloning(T prototype); static ObjectProvider<T> constant(T value); static ObjectProvider<T> nullValue(); static ObjectProvider<T> singleton(ObjectProvider<T> inner); }### Answer:
@Test public void testCloning() throws Exception { assertTrue(ObjectProviderUtils.cloning(new Date()) instanceof CloningProvider); }
|
### Question:
ObjectProviderUtils { public static <T> ObjectProvider<T> constant(T value) { return new ConstantProvider<T>(value); } private ObjectProviderUtils(); static ObjectProvider<T> bean(Class<T> beanClass); static ObjectProvider<T> cloning(T prototype); static ObjectProvider<T> constant(T value); static ObjectProvider<T> nullValue(); static ObjectProvider<T> singleton(ObjectProvider<T> inner); }### Answer:
@Test public void testConstant() throws Exception { assertTrue(ObjectProviderUtils.constant("Hello") instanceof ConstantProvider); }
|
### Question:
ObjectProviderUtils { public static <T> ObjectProvider<T> nullValue() { return new NullProvider<T>(); } private ObjectProviderUtils(); static ObjectProvider<T> bean(Class<T> beanClass); static ObjectProvider<T> cloning(T prototype); static ObjectProvider<T> constant(T value); static ObjectProvider<T> nullValue(); static ObjectProvider<T> singleton(ObjectProvider<T> inner); }### Answer:
@Test public void testNullValue() throws Exception { assertTrue(ObjectProviderUtils.nullValue() instanceof NullProvider); }
|
### Question:
ObjectProviderUtils { public static <T> ObjectProvider<T> singleton(ObjectProvider<T> inner) { return new SingletonProvider<T>(inner); } private ObjectProviderUtils(); static ObjectProvider<T> bean(Class<T> beanClass); static ObjectProvider<T> cloning(T prototype); static ObjectProvider<T> constant(T value); static ObjectProvider<T> nullValue(); static ObjectProvider<T> singleton(ObjectProvider<T> inner); }### Answer:
@Test public void testSingleton() throws Exception { assertTrue(ObjectProviderUtils.singleton(new ConstantProvider<Object>("Hello")) instanceof SingletonProvider); }
|
### Question:
ConstantProvider implements ObjectProvider<T>, Serializable { @Override public T getObject() { return constant; } ConstantProvider(T constant); @Override T getObject(); }### Answer:
@Test public void testGetObject() throws Exception { final String s = "Hello, World!"; final ConstantProvider<String> provider = new ConstantProvider<String>(s); assertSame(s, provider.getObject()); }
|
### Question:
Int2IntOpenHashMapWritable extends Int2IntOpenHashMap implements Writable { public void increment(int key) { increment(key, 1); } Int2IntOpenHashMapWritable(); @Override void readFields(DataInput in); void decode(); boolean hasBeenDecoded(); @Override void write(DataOutput out); byte[] serialize(); static Int2IntOpenHashMapWritable create(DataInput in); static Int2IntOpenHashMapWritable create(byte[] bytes); void plus(Int2IntOpenHashMapWritable m); long dot(Int2IntOpenHashMapWritable m); void increment(int key); void increment(int key, int n); static void setLazyDecodeFlag(boolean b); static boolean getLazyDecodeFlag(); int[] getKeys(); int[] getValues(); void lazyplus(Int2IntOpenHashMapWritable m); Int2IntMap.Entry[] getEntriesSortedByValue(); Int2IntMap.Entry[] getEntriesSortedByValue(int k); }### Answer:
@Test public void testIncrement() throws IOException { Int2IntOpenHashMapWritable m = new Int2IntOpenHashMapWritable(); m.put(2, 7); m.put(1, 29); assertEquals(7, m.get(2)); assertEquals(29, m.get(1)); m.increment(2); m.increment(1); m.increment(3); assertEquals(8, m.get(2)); assertEquals(30, m.get(1)); assertEquals(1, m.get(3)); m.increment(1, 3); m.increment(3, 5); assertEquals(8, m.get(2)); assertEquals(33, m.get(1)); assertEquals(6, m.get(3)); }
|
### Question:
ArrayListWritable extends ArrayList<E> implements Writable { public String toString() { StringBuffer sb = new StringBuffer(); sb.append("["); for (int i = 0; i < this.size(); i++) { if (i != 0) sb.append(", "); sb.append(this.get(i)); } sb.append("]"); return sb.toString(); } ArrayListWritable(); ArrayListWritable(ArrayList<E> array); @SuppressWarnings("unchecked") void readFields(DataInput in); void write(DataOutput out); String toString(); }### Answer:
@Test public void testBasic() throws IOException { ArrayListWritable<Text> list = new ArrayListWritable<Text>(); list.add(new Text("hi")); list.add(new Text("there")); assertEquals(list.get(0).toString(), "hi"); assertEquals(list.get(1).toString(), "there"); }
@Test public void testToString() { ArrayListWritable<Text> list = new ArrayListWritable<Text>(); list.add(new Text("hi")); list.add(new Text("there")); assertEquals(list.toString(), "[hi, there]"); }
|
### Question:
HMapII implements MapII, Cloneable, Serializable { @Override public void plus(MapII m) { for (MapII.Entry e : m.entrySet()) { int key = e.getKey(); if (this.containsKey(key)) { this.put(key, this.get(key) + e.getValue()); } else { this.put(key, e.getValue()); } } } HMapII(int initialCapacity, float loadFactor); HMapII(int initialCapacity); HMapII(); HMapII(MapII m); @Override int size(); @Override boolean isEmpty(); @Override int get(int key); @Override boolean containsKey(int key); @Override int put(int key, int value); @Override void putAll(MapII m); @Override int remove(int key); @Override void clear(); @Override boolean containsValue(int value); @Override Object clone(); @Override Set<Integer> keySet(); @Override Collection<Integer> values(); @Override Set<MapII.Entry> entrySet(); @Override String toString(); @Override void plus(MapII m); @Override long dot(MapII m); @Override void increment(int key); @Override void increment(int key, int value); MapII.Entry[] getEntriesSortedByValue(); MapII.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testPlus() throws IOException { HMapII m1 = new HMapII(); m1.put(1, 5); m1.put(2, 22); HMapII m2 = new HMapII(); m2.put(1, 4); m2.put(3, 5); m1.plus(m2); assertEquals(m1.size(), 3); assertTrue(m1.get(1) == 9); assertTrue(m1.get(2) == 22); assertTrue(m1.get(3) == 5); }
|
### Question:
HMapII implements MapII, Cloneable, Serializable { @Override public long dot(MapII m) { int s = 0; for (MapII.Entry e : m.entrySet()) { int key = e.getKey(); if (this.containsKey(key)) { s += this.get(key) * e.getValue(); } } return s; } HMapII(int initialCapacity, float loadFactor); HMapII(int initialCapacity); HMapII(); HMapII(MapII m); @Override int size(); @Override boolean isEmpty(); @Override int get(int key); @Override boolean containsKey(int key); @Override int put(int key, int value); @Override void putAll(MapII m); @Override int remove(int key); @Override void clear(); @Override boolean containsValue(int value); @Override Object clone(); @Override Set<Integer> keySet(); @Override Collection<Integer> values(); @Override Set<MapII.Entry> entrySet(); @Override String toString(); @Override void plus(MapII m); @Override long dot(MapII m); @Override void increment(int key); @Override void increment(int key, int value); MapII.Entry[] getEntriesSortedByValue(); MapII.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testDot() throws IOException { HMapII m1 = new HMapII(); m1.put(1, 2); m1.put(2, 1); m1.put(3, 3); HMapII m2 = new HMapII(); m2.put(1, 1); m2.put(2, 4); m2.put(4, 5); assertEquals(6, m1.dot(m2)); }
|
### Question:
HMapII implements MapII, Cloneable, Serializable { @Override public void increment(int key) { if (this.containsKey(key)) { this.put(key, this.get(key) + 1); } else { this.put(key, 1); } } HMapII(int initialCapacity, float loadFactor); HMapII(int initialCapacity); HMapII(); HMapII(MapII m); @Override int size(); @Override boolean isEmpty(); @Override int get(int key); @Override boolean containsKey(int key); @Override int put(int key, int value); @Override void putAll(MapII m); @Override int remove(int key); @Override void clear(); @Override boolean containsValue(int value); @Override Object clone(); @Override Set<Integer> keySet(); @Override Collection<Integer> values(); @Override Set<MapII.Entry> entrySet(); @Override String toString(); @Override void plus(MapII m); @Override long dot(MapII m); @Override void increment(int key); @Override void increment(int key, int value); MapII.Entry[] getEntriesSortedByValue(); MapII.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testIncrement() { HMapII m = new HMapII(); assertEquals(0, m.get(1)); m.increment(1); assertEquals(1, m.get(1)); m.increment(1, 5); m.increment(2, 0); m.increment(3, 2); assertEquals(6, m.get(1)); assertEquals(0, m.get(2)); assertEquals(2, m.get(3)); }
|
### Question:
HMapII implements MapII, Cloneable, Serializable { @Override public int put(int key, int value) { int hash = hash(key); int i = indexFor(hash, table.length); for (Entry e = table[i]; e != null; e = e.next) { int k; if (e.hash == hash && ((k = e.key) == key || key == k)) { int oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } modCount++; addEntry(hash, key, value, i); return DEFAULT_VALUE; } HMapII(int initialCapacity, float loadFactor); HMapII(int initialCapacity); HMapII(); HMapII(MapII m); @Override int size(); @Override boolean isEmpty(); @Override int get(int key); @Override boolean containsKey(int key); @Override int put(int key, int value); @Override void putAll(MapII m); @Override int remove(int key); @Override void clear(); @Override boolean containsValue(int value); @Override Object clone(); @Override Set<Integer> keySet(); @Override Collection<Integer> values(); @Override Set<MapII.Entry> entrySet(); @Override String toString(); @Override void plus(MapII m); @Override long dot(MapII m); @Override void increment(int key); @Override void increment(int key, int value); MapII.Entry[] getEntriesSortedByValue(); MapII.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testPut() { HMapII m = new HMapII(); assertEquals(MapII.DEFAULT_VALUE, m.put(1, 5)); assertEquals(5, m.put(1, 6)); assertEquals(6, m.put(1, 2)); assertEquals(2, m.get(1)); }
|
### Question:
HMapILW extends HMapIL implements Writable { @Override public int size() { if (!isDecoded()) { return keys.length; } return super.size(); } HMapILW(); void readFields(DataInput in); void decode(); boolean isDecoded(); void write(DataOutput out); byte[] serialize(); static HMapILW create(DataInput in); static HMapILW create(byte[] bytes); static void setLazyDecodeFlag(boolean b); static boolean getLazyDecodeFlag(); int[] getKeys(); long[] getValues(); void lazyplus(HMapILW m); @Override int size(); }### Answer:
@Test public void testBasic() throws IOException { HMapILW m = new HMapILW(); m.put(2, Integer.MAX_VALUE + 5L); m.put(1, Integer.MAX_VALUE + 22L); long value; assertEquals(m.size(), 2); value = m.get(2); assertEquals(Integer.MAX_VALUE + 5L, value); assertTrue(value > 0); value = m.remove(2); assertEquals(m.size(), 1); value = m.get(1); assertEquals(Integer.MAX_VALUE + 22L, value); assertTrue(value > 0); }
|
### Question:
HMapIFW extends HMapIF implements Writable { @Override public int size() { if (!isDecoded()) { return keys.length; } return super.size(); } HMapIFW(); void readFields(DataInput in); void decode(); boolean isDecoded(); void write(DataOutput out); byte[] serialize(); static HMapIFW create(DataInput in); static HMapIFW create(byte[] bytes); static void setLazyDecodeFlag(boolean b); static boolean getLazyDecodeFlag(); int[] getKeys(); float[] getValues(); void plus(HMapIFW m); @Override int size(); }### Answer:
@Test public void testBasic() throws IOException { HMapIFW m = new HMapIFW(); m.put(2, 5.0f); m.put(1, 22.0f); float value; assertEquals(m.size(), 2); value = m.get(2); assertTrue(value == 5.0f); value = m.remove(2); assertEquals(m.size(), 1); value = m.get(1); assertTrue(value == 22.0f); }
|
### Question:
HMapKS implements MapKS<K>, Cloneable, Serializable { @Override public void plus(MapKS<K> m) { for (MapKS.Entry<K> e : m.entrySet()) { K key = e.getKey(); if (this.containsKey(key)) { this.put(key, (short) (this.get(key) + e.getValue())); } else { this.put(key, e.getValue()); } } } @SuppressWarnings("unchecked") HMapKS(int initialCapacity, float loadFactor); HMapKS(int initialCapacity); @SuppressWarnings("unchecked") HMapKS(); HMapKS(MapKS<? extends K> m); int size(); boolean isEmpty(); short get(K key); boolean containsKey(K key); short put(K key, short value); void putAll(MapKS<? extends K> m); short remove(K key); void clear(); boolean containsValue(short value); @SuppressWarnings("unchecked") Object clone(); Set<K> keySet(); Collection<Short> values(); Set<MapKS.Entry<K>> entrySet(); String toString(); @Override void plus(MapKS<K> m); @Override long dot(MapKS<K> m); @Override void increment(K key); @Override void increment(K key, short value); }### Answer:
@Test public void testPlus() throws IOException { HMapKS<Text> m1 = new HMapKS<Text>(); m1.put(new Text("hi"), (short) 5); m1.put(new Text("there"), (short) 22); HMapKS<Text> m2 = new HMapKS<Text>(); m2.put(new Text("hi"), (short) 4); m2.put(new Text("test"), (short) 5); m1.plus(m2); assertEquals(3, m1.size()); assertTrue(m1.get(new Text("hi")) == 9); assertTrue(m1.get(new Text("there")) == 22); assertTrue(m1.get(new Text("test")) == 5); }
|
### Question:
HMapKS implements MapKS<K>, Cloneable, Serializable { @Override public long dot(MapKS<K> m) { int s = 0; for (MapKS.Entry<K> e : m.entrySet()) { K key = e.getKey(); if (this.containsKey(key)) { s += this.get(key) * e.getValue(); } } return s; } @SuppressWarnings("unchecked") HMapKS(int initialCapacity, float loadFactor); HMapKS(int initialCapacity); @SuppressWarnings("unchecked") HMapKS(); HMapKS(MapKS<? extends K> m); int size(); boolean isEmpty(); short get(K key); boolean containsKey(K key); short put(K key, short value); void putAll(MapKS<? extends K> m); short remove(K key); void clear(); boolean containsValue(short value); @SuppressWarnings("unchecked") Object clone(); Set<K> keySet(); Collection<Short> values(); Set<MapKS.Entry<K>> entrySet(); String toString(); @Override void plus(MapKS<K> m); @Override long dot(MapKS<K> m); @Override void increment(K key); @Override void increment(K key, short value); }### Answer:
@Test public void testDot() throws IOException { HMapKS<Text> m1 = new HMapKS<Text>(); m1.put(new Text("hi"), (short) 5); m1.put(new Text("there"), (short) 2); m1.put(new Text("empty"), (short) 3); HMapKS<Text> m2 = new HMapKS<Text>(); m2.put(new Text("hi"), (short) 4); m2.put(new Text("there"), (short) 4); m2.put(new Text("test"), (short) 5); assertEquals(28, m1.dot(m2)); }
|
### Question:
HMapKS implements MapKS<K>, Cloneable, Serializable { @Override public void increment(K key) { if (this.containsKey(key)) { this.put(key, (short) (this.get(key) + 1)); } else { this.put(key, (short) 1); } } @SuppressWarnings("unchecked") HMapKS(int initialCapacity, float loadFactor); HMapKS(int initialCapacity); @SuppressWarnings("unchecked") HMapKS(); HMapKS(MapKS<? extends K> m); int size(); boolean isEmpty(); short get(K key); boolean containsKey(K key); short put(K key, short value); void putAll(MapKS<? extends K> m); short remove(K key); void clear(); boolean containsValue(short value); @SuppressWarnings("unchecked") Object clone(); Set<K> keySet(); Collection<Short> values(); Set<MapKS.Entry<K>> entrySet(); String toString(); @Override void plus(MapKS<K> m); @Override long dot(MapKS<K> m); @Override void increment(K key); @Override void increment(K key, short value); }### Answer:
@Test public void testIncrement() { HMapKS<String> m = new HMapKS<String>(); assertEquals(0, m.get("one")); m.increment("one", (short) 1); assertEquals(1, m.get("one")); m.increment("one", (short) 1); m.increment("two", (short) 0); m.increment("three", (short) -1); assertEquals(2, m.get("one")); assertEquals(0, m.get("two")); assertEquals(-1, m.get("three")); }
|
### Question:
HMapIDW extends HMapID implements Writable { @Override public int size() { if (!isDecoded()) { return keys.length; } return super.size(); } HMapIDW(); void readFields(DataInput in); void decode(); boolean isDecoded(); void write(DataOutput out); byte[] serialize(); static HMapIDW create(DataInput in); static HMapIDW create(byte[] bytes); static void setLazyDecodeFlag(boolean b); static boolean getLazyDecodeFlag(); int[] getKeys(); double[] getValues(); void plus(HMapIDW m); @Override int size(); }### Answer:
@Test public void testBasic() throws IOException { HMapIDW m = new HMapIDW(); m.put(2, 5.0); m.put(1, 22.0); double value; assertEquals(m.size(), 2); value = m.get(2); assertTrue(value == 5.0); value = m.remove(2); assertEquals(m.size(), 1); value = m.get(1); assertTrue(value == 22.0); }
|
### Question:
HMapKI implements MapKI<K>, Cloneable, Serializable { @Override public void increment(K key) { if (this.containsKey(key)) { this.put(key, this.get(key) + 1); } else { this.put(key, 1); } } @SuppressWarnings("unchecked") HMapKI(int initialCapacity, float loadFactor); HMapKI(int initialCapacity); @SuppressWarnings("unchecked") HMapKI(); HMapKI(MapKI<? extends K> m); @Override int size(); @Override boolean isEmpty(); @Override int get(K key); @Override boolean containsKey(K key); @Override int put(K key, int value); @Override void putAll(MapKI<? extends K> m); @Override int remove(K key); @Override void clear(); @Override boolean containsValue(int value); @SuppressWarnings("unchecked") @Override Object clone(); @Override Set<K> keySet(); @Override Collection<Integer> values(); @Override Set<MapKI.Entry<K>> entrySet(); @Override String toString(); @Override void plus(MapKI<K> m); @Override long dot(MapKI<K> m); @Override void increment(K key); @Override void increment(K key, int value); @SuppressWarnings("unchecked") MapKI.Entry<K>[] getEntriesSortedByValue(); MapKI.Entry<K>[] getEntriesSortedByValue(int n); @SuppressWarnings("unchecked") MapKI.Entry<K>[] getEntriesSortedByKey(); MapKI.Entry<K>[] getEntriesSortedByKey(int n); }### Answer:
@Test public void testIncrement() { HMapKI<String> m = new HMapKI<String>(); assertEquals(0, m.get("one")); m.increment("one"); assertEquals(1, m.get("one")); m.increment("one", 5); m.increment("two", 0); m.increment("three", 2); assertEquals(6, m.get("one")); assertEquals(0, m.get("two")); assertEquals(2, m.get("three")); }
|
### Question:
HMapIV implements MapIV<V>, Cloneable, Serializable { @SuppressWarnings("unchecked") public MapIV.Entry<V>[] getEntriesSortedByValue() { if (this.size() == 0) return null; MapIV.Entry<V>[] entries = new Entry[this.size()]; int i = 0; Entry<V> next = null; int index = 0; while (index < table.length && (next = table[index++]) == null) ; while (next != null) { Entry<V> e = next; next = e.next; if ((next = e.next) == null) { while (index < table.length && (next = table[index++]) == null) ; } entries[i++] = e; } Arrays.sort(entries, new Comparator<MapIV.Entry<V>>() { public int compare(MapIV.Entry<V> e1, MapIV.Entry<V> e2) { return ((Comparable<V>) e1.getValue()).compareTo(e2.getValue()); } }); return entries; } @SuppressWarnings("unchecked") HMapIV(int initialCapacity, float loadFactor); HMapIV(int initialCapacity); @SuppressWarnings("unchecked") HMapIV(); HMapIV(MapIV<V> m); int size(); boolean isEmpty(); V get(int key); boolean containsKey(int key); V put(int key, V value); void putAll(MapIV<V> m); V remove(int key); void clear(); boolean containsValue(V value); @SuppressWarnings("unchecked") Object clone(); Set<Integer> keySet(); Collection<V> values(); Set<MapIV.Entry<V>> entrySet(); String toString(); @SuppressWarnings("unchecked") MapIV.Entry<V>[] getEntriesSortedByValue(); MapIV.Entry<V>[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testSortedEntries4() { HMapIV<String> m = new HMapIV<String>(); MapIV.Entry<String>[] e = m.getEntriesSortedByValue(); assertTrue(e == null); }
|
### Question:
HMapIIW extends HMapII implements Writable { @Override public int size() { if (!isDecoded()) { return keys.length; } return super.size(); } HMapIIW(); void readFields(DataInput in); void decode(); boolean isDecoded(); void write(DataOutput out); byte[] serialize(); static HMapIIW create(DataInput in); static HMapIIW create(byte[] bytes); static void setLazyDecodeFlag(boolean b); static boolean getLazyDecodeFlag(); int[] getKeys(); int[] getValues(); void lazyplus(HMapIIW m); @Override int size(); }### Answer:
@Test public void testBasic() throws IOException { HMapIIW m = new HMapIIW(); m.put(2, 5); m.put(1, 22); int value; assertEquals(m.size(), 2); value = m.get(2); assertEquals(5, value); value = m.remove(2); assertEquals(m.size(), 1); value = m.get(1); assertEquals(22, value); }
|
### Question:
Int2LongOpenHashMapWritable extends Int2LongOpenHashMap implements Writable { public long dot(Int2LongOpenHashMapWritable m) { int s = 0; for (Int2LongMap.Entry e : m.int2LongEntrySet()) { int key = e.getIntKey(); if (this.containsKey(key)) { s += this.get(key) * e.getLongValue(); } } return s; } Int2LongOpenHashMapWritable(); void readFields(DataInput in); void decode(); boolean hasBeenDecoded(); void write(DataOutput out); byte[] serialize(); static Int2LongOpenHashMapWritable create(DataInput in); static Int2LongOpenHashMapWritable create(byte[] bytes); void plus(Int2LongOpenHashMapWritable m); long dot(Int2LongOpenHashMapWritable m); void increment(int key); void increment(int key, long n); static void setLazyDecodeFlag(boolean b); static boolean getLazyDecodeFlag(); int[] getKeys(); long[] getValues(); void lazyplus(Int2LongOpenHashMapWritable m); Int2LongMap.Entry[] getEntriesSortedByValue(); Int2LongMap.Entry[] getEntriesSortedByValue(int k); }### Answer:
@Test public void testDot() throws IOException { Int2LongOpenHashMapWritable m1 = new Int2LongOpenHashMapWritable(); m1.put(1, 2L); m1.put(2, 1L); m1.put(3, 3L); Int2LongOpenHashMapWritable m2 = new Int2LongOpenHashMapWritable(); m2.put(1, 1L); m2.put(2, 4L); m2.put(4, 5L); long s = m1.dot(m2); assertEquals(6, s); }
|
### Question:
HMapIL implements MapIL, Cloneable, Serializable { @Override public long dot(MapIL m) { long s = 0; for (MapIL.Entry e : m.entrySet()) { int key = e.getKey(); if (this.containsKey(key)) { s += this.get(key) * e.getValue(); } } return s; } HMapIL(int initialCapacity, float loadFactor); HMapIL(int initialCapacity); HMapIL(); HMapIL(MapIL m); @Override int size(); @Override boolean isEmpty(); @Override long get(int key); @Override boolean containsKey(int key); @Override long put(int key, long value); @Override void putAll(MapIL m); @Override long remove(int key); @Override void clear(); @Override boolean containsValue(long value); @Override Object clone(); @Override Set<Integer> keySet(); @Override Collection<Long> values(); @Override Set<MapIL.Entry> entrySet(); @Override String toString(); @Override void plus(MapIL m); @Override long dot(MapIL m); @Override void increment(int key); @Override void increment(int key, long value); MapIL.Entry[] getEntriesSortedByValue(); MapIL.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testDot() throws IOException { HMapIL m1 = new HMapIL(); m1.put(1, 2L); m1.put(2, 1L); m1.put(3, 3L); m1.put(Integer.MAX_VALUE, (long) Integer.MAX_VALUE); HMapIL m2 = new HMapIL(); m2.put(1, 1L); m2.put(2, 4L); m2.put(4, 5L); m2.put(Integer.MAX_VALUE, (long) Integer.MAX_VALUE); long s = m1.dot(m2); assertTrue(s > Integer.MAX_VALUE); assertEquals((long) Integer.MAX_VALUE * Integer.MAX_VALUE + 6L, s); }
|
### Question:
HMapIL implements MapIL, Cloneable, Serializable { @Override public void increment(int key) { if (this.containsKey(key)) { this.put(key, (long) (this.get(key) + 1)); } else { this.put(key, (long) 1); } } HMapIL(int initialCapacity, float loadFactor); HMapIL(int initialCapacity); HMapIL(); HMapIL(MapIL m); @Override int size(); @Override boolean isEmpty(); @Override long get(int key); @Override boolean containsKey(int key); @Override long put(int key, long value); @Override void putAll(MapIL m); @Override long remove(int key); @Override void clear(); @Override boolean containsValue(long value); @Override Object clone(); @Override Set<Integer> keySet(); @Override Collection<Long> values(); @Override Set<MapIL.Entry> entrySet(); @Override String toString(); @Override void plus(MapIL m); @Override long dot(MapIL m); @Override void increment(int key); @Override void increment(int key, long value); MapIL.Entry[] getEntriesSortedByValue(); MapIL.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testIncrement() { HMapIL m = new HMapIL(); assertEquals(0L, m.get(1)); m.increment(1, 1L); assertEquals(1L, m.get(1)); m.increment(1, 1L); m.increment(2, 0L); m.increment(3, -1L); assertEquals(2L, m.get(1)); assertEquals(0L, m.get(2)); assertEquals(-1L, m.get(3)); m.increment(Integer.MAX_VALUE, Integer.MAX_VALUE); assertEquals((long) Integer.MAX_VALUE, m.get(Integer.MAX_VALUE)); m.increment(Integer.MAX_VALUE); assertEquals(1L + Integer.MAX_VALUE, m.get(Integer.MAX_VALUE)); }
|
### Question:
HMapID implements MapID, Cloneable, Serializable { @Override public void plus(MapID m) { for (MapID.Entry e : m.entrySet()) { int key = e.getKey(); if (this.containsKey(key)) { this.put(key, this.get(key) + e.getValue()); } else { this.put(key, e.getValue()); } } } HMapID(int initialCapacity, float loadFactor); HMapID(int initialCapacity); HMapID(); HMapID(MapID m); int size(); boolean isEmpty(); double get(int key); boolean containsKey(int key); double put(int key, double value); void putAll(MapID m); double remove(int key); void clear(); boolean containsValue(double value); Object clone(); Set<Integer> keySet(); Collection<Double> values(); Set<MapID.Entry> entrySet(); String toString(); @Override void plus(MapID m); @Override double dot(MapID m); @Override void increment(int key); @Override void increment(int key, double value); double length(); void normalize(); MapID.Entry[] getEntriesSortedByValue(); MapID.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testPlus() throws IOException { HMapID m1 = new HMapID(); m1.put(1, 5.0); m1.put(2, 22.0); HMapID m2 = new HMapID(); m2.put(1, 4.0); m2.put(3, 5.0); m1.plus(m2); assertEquals(m1.size(), 3); assertTrue(m1.get(1) == 9); assertTrue(m1.get(2) == 22); assertTrue(m1.get(3) == 5); }
|
### Question:
HMapID implements MapID, Cloneable, Serializable { @Override public double dot(MapID m) { double s = 0.0f; for (MapID.Entry e : m.entrySet()) { int key = e.getKey(); if (this.containsKey(key)) { s += this.get(key) * e.getValue(); } } return s; } HMapID(int initialCapacity, float loadFactor); HMapID(int initialCapacity); HMapID(); HMapID(MapID m); int size(); boolean isEmpty(); double get(int key); boolean containsKey(int key); double put(int key, double value); void putAll(MapID m); double remove(int key); void clear(); boolean containsValue(double value); Object clone(); Set<Integer> keySet(); Collection<Double> values(); Set<MapID.Entry> entrySet(); String toString(); @Override void plus(MapID m); @Override double dot(MapID m); @Override void increment(int key); @Override void increment(int key, double value); double length(); void normalize(); MapID.Entry[] getEntriesSortedByValue(); MapID.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testDot() throws IOException { HMapID m1 = new HMapID(); m1.put(1, 2.3); m1.put(2, 1.9); m1.put(3, 3.0); HMapID m2 = new HMapID(); m2.put(1, 1.2); m2.put(2, 4.3); m2.put(4, 5.0); double s = m1.dot(m2); assertTrue(s == 10.93); }
|
### Question:
HMapID implements MapID, Cloneable, Serializable { @Override public void increment(int key) { if (this.containsKey(key)) { this.put(key, this.get(key) + 1.0); } else { this.put(key, 1.0); } } HMapID(int initialCapacity, float loadFactor); HMapID(int initialCapacity); HMapID(); HMapID(MapID m); int size(); boolean isEmpty(); double get(int key); boolean containsKey(int key); double put(int key, double value); void putAll(MapID m); double remove(int key); void clear(); boolean containsValue(double value); Object clone(); Set<Integer> keySet(); Collection<Double> values(); Set<MapID.Entry> entrySet(); String toString(); @Override void plus(MapID m); @Override double dot(MapID m); @Override void increment(int key); @Override void increment(int key, double value); double length(); void normalize(); MapID.Entry[] getEntriesSortedByValue(); MapID.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testIncrement() { HMapID m = new HMapID(); assertEquals(0.0, m.get(1), 10E-6); m.increment(1, 0.5); assertEquals(0.5, m.get(1), 10E-6); m.increment(1); m.increment(2, 0.0); m.increment(3, -0.5); assertEquals(1.5, m.get(1), 10E-6); assertEquals(0.0, m.get(2), 10E-6); assertEquals(-0.5, m.get(3), 10E-6); }
|
### Question:
HMapID implements MapID, Cloneable, Serializable { public MapID.Entry[] getEntriesSortedByValue() { if (this.size() == 0) return null; MapID.Entry[] entries = new Entry[this.size()]; int i = 0; Entry next = null; int index = 0; while (index < table.length && (next = table[index++]) == null) ; while (next != null) { Entry e = next; next = e.next; if ((next = e.next) == null) { while (index < table.length && (next = table[index++]) == null) ; } entries[i++] = e; } Arrays.sort(entries, new Comparator<MapID.Entry>() { public int compare(MapID.Entry e1, MapID.Entry e2) { if (e1.getValue() > e2.getValue()) { return -1; } else if (e1.getValue() < e2.getValue()) { return 1; } if (e1.getKey() == e2.getKey()) return 0; return e1.getKey() > e2.getKey() ? 1 : -1; } }); return entries; } HMapID(int initialCapacity, float loadFactor); HMapID(int initialCapacity); HMapID(); HMapID(MapID m); int size(); boolean isEmpty(); double get(int key); boolean containsKey(int key); double put(int key, double value); void putAll(MapID m); double remove(int key); void clear(); boolean containsValue(double value); Object clone(); Set<Integer> keySet(); Collection<Double> values(); Set<MapID.Entry> entrySet(); String toString(); @Override void plus(MapID m); @Override double dot(MapID m); @Override void increment(int key); @Override void increment(int key, double value); double length(); void normalize(); MapID.Entry[] getEntriesSortedByValue(); MapID.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testSortedEntries4() { HMapID m = new HMapID(); MapID.Entry[] e = m.getEntriesSortedByValue(); assertTrue(e == null); }
|
### Question:
HMapIS implements MapIS, Cloneable, Serializable { @Override public void plus(MapIS m) { for (MapIS.Entry e : m.entrySet()) { int key = e.getKey(); if (this.containsKey(key)) { this.put(key, (short) (this.get(key) + e.getValue())); } else { this.put(key, e.getValue()); } } } HMapIS(int initialCapacity, float loadFactor); HMapIS(int initialCapacity); HMapIS(); HMapIS(MapIS m); @Override int size(); @Override boolean isEmpty(); @Override short get(int key); @Override boolean containsKey(int key); @Override short put(int key, short value); @Override void putAll(MapIS m); @Override short remove(int key); @Override void clear(); @Override boolean containsValue(short value); @Override Object clone(); @Override Set<Integer> keySet(); @Override Collection<Short> values(); @Override Set<MapIS.Entry> entrySet(); @Override String toString(); @Override void plus(MapIS m); @Override long dot(MapIS m); @Override void increment(int key); @Override void increment(int key, short value); MapIS.Entry[] getEntriesSortedByValue(); MapIS.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testPlus() throws IOException { HMapIS m1 = new HMapIS(); m1.put(1, (short) 5); m1.put(2, (short) 22); HMapIS m2 = new HMapIS(); m2.put(1, (short) 4); m2.put(3, (short) 5); m1.plus(m2); assertEquals(m1.size(), 3); assertTrue(m1.get(1) == 9); assertTrue(m1.get(2) == 22); assertTrue(m1.get(3) == 5); }
|
### Question:
HMapIS implements MapIS, Cloneable, Serializable { @Override public long dot(MapIS m) { int s = 0; for (MapIS.Entry e : m.entrySet()) { int key = e.getKey(); if (this.containsKey(key)) { s += this.get(key) * e.getValue(); } } return s; } HMapIS(int initialCapacity, float loadFactor); HMapIS(int initialCapacity); HMapIS(); HMapIS(MapIS m); @Override int size(); @Override boolean isEmpty(); @Override short get(int key); @Override boolean containsKey(int key); @Override short put(int key, short value); @Override void putAll(MapIS m); @Override short remove(int key); @Override void clear(); @Override boolean containsValue(short value); @Override Object clone(); @Override Set<Integer> keySet(); @Override Collection<Short> values(); @Override Set<MapIS.Entry> entrySet(); @Override String toString(); @Override void plus(MapIS m); @Override long dot(MapIS m); @Override void increment(int key); @Override void increment(int key, short value); MapIS.Entry[] getEntriesSortedByValue(); MapIS.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testDot() throws IOException { HMapIS m1 = new HMapIS(); m1.put(1, (short) 2); m1.put(2, (short) 1); m1.put(3, (short) 3); HMapIS m2 = new HMapIS(); m2.put(1, (short) 1); m2.put(2, (short) 4); m2.put(4, (short) 5); long s = m1.dot(m2); assertEquals(6, s); }
|
### Question:
HMapIS implements MapIS, Cloneable, Serializable { @Override public void increment(int key) { if (this.containsKey(key)) { this.put(key, (short) (this.get(key) + 1)); } else { this.put(key, (short) 1); } } HMapIS(int initialCapacity, float loadFactor); HMapIS(int initialCapacity); HMapIS(); HMapIS(MapIS m); @Override int size(); @Override boolean isEmpty(); @Override short get(int key); @Override boolean containsKey(int key); @Override short put(int key, short value); @Override void putAll(MapIS m); @Override short remove(int key); @Override void clear(); @Override boolean containsValue(short value); @Override Object clone(); @Override Set<Integer> keySet(); @Override Collection<Short> values(); @Override Set<MapIS.Entry> entrySet(); @Override String toString(); @Override void plus(MapIS m); @Override long dot(MapIS m); @Override void increment(int key); @Override void increment(int key, short value); MapIS.Entry[] getEntriesSortedByValue(); MapIS.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testIncrement() { HMapIS m = new HMapIS(); assertEquals(0, m.get(1)); m.increment(1, (short) 1); assertEquals(1, m.get(1)); m.increment(1); m.increment(2, (short) 0); m.increment(3, (short) -1); assertEquals(2, m.get(1)); assertEquals(0, m.get(2)); assertEquals(-1, m.get(3)); }
|
### Question:
HMapKL implements MapKL<K>, Cloneable, Serializable { @Override public long dot(MapKL<K> m) { long s = 0; for (MapKL.Entry<K> e : m.entrySet()) { K key = e.getKey(); if (this.containsKey(key)) { s += this.get(key) * e.getValue(); } } return s; } @SuppressWarnings("unchecked") HMapKL(int initialCapacity, float loadFactor); HMapKL(int initialCapacity); @SuppressWarnings("unchecked") HMapKL(); HMapKL(MapKL<? extends K> m); int size(); boolean isEmpty(); long get(K key); boolean containsKey(K key); long put(K key, long value); void putAll(MapKL<? extends K> m); long remove(K key); void clear(); boolean containsValue(long value); @SuppressWarnings("unchecked") Object clone(); Set<K> keySet(); Collection<Long> values(); Set<MapKL.Entry<K>> entrySet(); String toString(); @Override void plus(MapKL<K> m); @Override long dot(MapKL<K> m); @Override void increment(K key); @Override void increment(K key, long value); }### Answer:
@Test public void testDot() throws IOException { HMapKL<String> m1 = new HMapKL<String>(); m1.put("1", 2L); m1.put("2", 1L); m1.put("3", 3L); m1.put("" + Integer.MAX_VALUE, (long) Integer.MAX_VALUE); HMapKL<String> m2 = new HMapKL<String>(); m2.put("1", 1L); m2.put("2", 4L); m2.put("4", 5L); m2.put("" + Integer.MAX_VALUE, (long) Integer.MAX_VALUE); long s = m1.dot(m2); assertTrue(s > Integer.MAX_VALUE); assertEquals((long) Integer.MAX_VALUE * Integer.MAX_VALUE + 6L, s); }
|
### Question:
HMapKL implements MapKL<K>, Cloneable, Serializable { @Override public void increment(K key) { if (this.containsKey(key)) { this.put(key, (long) this.get(key) + 1L); } else { this.put(key, (long) 1L); } } @SuppressWarnings("unchecked") HMapKL(int initialCapacity, float loadFactor); HMapKL(int initialCapacity); @SuppressWarnings("unchecked") HMapKL(); HMapKL(MapKL<? extends K> m); int size(); boolean isEmpty(); long get(K key); boolean containsKey(K key); long put(K key, long value); void putAll(MapKL<? extends K> m); long remove(K key); void clear(); boolean containsValue(long value); @SuppressWarnings("unchecked") Object clone(); Set<K> keySet(); Collection<Long> values(); Set<MapKL.Entry<K>> entrySet(); String toString(); @Override void plus(MapKL<K> m); @Override long dot(MapKL<K> m); @Override void increment(K key); @Override void increment(K key, long value); }### Answer:
@Test public void testIncrement() { HMapKL<String> m = new HMapKL<String>(); assertEquals(0L, m.get("1")); m.increment("1", 1L); assertEquals(1L, m.get("1")); m.increment("1", 1L); m.increment("2", 0L); m.increment("3", -1L); assertEquals(2L, m.get("1")); assertEquals(0L, m.get("2")); assertEquals(-1L, m.get("3")); m.increment("" + Integer.MAX_VALUE, Integer.MAX_VALUE); assertEquals((long) Integer.MAX_VALUE, m.get("" + Integer.MAX_VALUE)); m.increment("" + Integer.MAX_VALUE); assertEquals(1L + Integer.MAX_VALUE, m.get("" + Integer.MAX_VALUE)); }
|
### Question:
HMapIF implements MapIF, Cloneable, Serializable { @Override public void plus(MapIF m) { for (MapIF.Entry e : m.entrySet()) { int key = e.getKey(); if (this.containsKey(key)) { this.put(key, this.get(key) + e.getValue()); } else { this.put(key, e.getValue()); } } } HMapIF(int initialCapacity, float loadFactor); HMapIF(int initialCapacity); HMapIF(); HMapIF(MapIF m); int size(); boolean isEmpty(); float get(int key); boolean containsKey(int key); float put(int key, float value); void putAll(MapIF m); float remove(int key); void clear(); boolean containsValue(float value); Object clone(); Set<Integer> keySet(); Collection<Float> values(); Set<MapIF.Entry> entrySet(); String toString(); @Override void plus(MapIF m); @Override double dot(MapIF m); @Override void increment(int key); @Override void increment(int key, float value); float length(); void normalize(); MapIF.Entry[] getEntriesSortedByValue(); MapIF.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testPlus() throws IOException { HMapIF m1 = new HMapIF(); m1.put(1, 5.0f); m1.put(2, 22.0f); HMapIF m2 = new HMapIF(); m2.put(1, 4.0f); m2.put(3, 5.0f); m1.plus(m2); assertEquals(m1.size(), 3); assertTrue(m1.get(1) == 9); assertTrue(m1.get(2) == 22); assertTrue(m1.get(3) == 5); }
|
### Question:
HMapIF implements MapIF, Cloneable, Serializable { @Override public double dot(MapIF m) { double s = 0.0f; for (MapIF.Entry e : m.entrySet()) { int key = e.getKey(); if (this.containsKey(key)) { s += this.get(key) * e.getValue(); } } return s; } HMapIF(int initialCapacity, float loadFactor); HMapIF(int initialCapacity); HMapIF(); HMapIF(MapIF m); int size(); boolean isEmpty(); float get(int key); boolean containsKey(int key); float put(int key, float value); void putAll(MapIF m); float remove(int key); void clear(); boolean containsValue(float value); Object clone(); Set<Integer> keySet(); Collection<Float> values(); Set<MapIF.Entry> entrySet(); String toString(); @Override void plus(MapIF m); @Override double dot(MapIF m); @Override void increment(int key); @Override void increment(int key, float value); float length(); void normalize(); MapIF.Entry[] getEntriesSortedByValue(); MapIF.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testDot() throws IOException { HMapIF m1 = new HMapIF(); m1.put(1, 2.3f); m1.put(2, 1.9f); m1.put(3, 3.0f); HMapIF m2 = new HMapIF(); m2.put(1, 1.2f); m2.put(2, 4.3f); m2.put(4, 5.0f); assertEquals(10.93, m1.dot(m2), 10e-6); }
|
### Question:
HMapIF implements MapIF, Cloneable, Serializable { @Override public void increment(int key) { if (this.containsKey(key)) { this.put(key, (float) this.get(key) + 1.0f); } else { this.put(key, 1.0f); } } HMapIF(int initialCapacity, float loadFactor); HMapIF(int initialCapacity); HMapIF(); HMapIF(MapIF m); int size(); boolean isEmpty(); float get(int key); boolean containsKey(int key); float put(int key, float value); void putAll(MapIF m); float remove(int key); void clear(); boolean containsValue(float value); Object clone(); Set<Integer> keySet(); Collection<Float> values(); Set<MapIF.Entry> entrySet(); String toString(); @Override void plus(MapIF m); @Override double dot(MapIF m); @Override void increment(int key); @Override void increment(int key, float value); float length(); void normalize(); MapIF.Entry[] getEntriesSortedByValue(); MapIF.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testIncrement() { HMapIF m = new HMapIF(); assertEquals(0.0f, m.get(1), 10E-6); m.increment(1, 0.5f); assertEquals(0.5f, m.get(1), 10E-6); m.increment(1); m.increment(2, 0.0f); m.increment(3, -0.5f); assertEquals(1.5f, m.get(1), 10E-6); assertEquals(0.0f, m.get(2), 10E-6); assertEquals(-0.5f, m.get(3), 10E-6); }
|
### Question:
HMapIF implements MapIF, Cloneable, Serializable { public MapIF.Entry[] getEntriesSortedByValue() { if (this.size() == 0) return null; MapIF.Entry[] entries = new Entry[this.size()]; int i = 0; Entry next = null; int index = 0; while (index < table.length && (next = table[index++]) == null) ; while (next != null) { Entry e = next; next = e.next; if ((next = e.next) == null) { while (index < table.length && (next = table[index++]) == null) ; } entries[i++] = e; } Arrays.sort(entries, new Comparator<MapIF.Entry>() { public int compare(MapIF.Entry e1, MapIF.Entry e2) { if (e1.getValue() > e2.getValue()) { return -1; } else if (e1.getValue() < e2.getValue()) { return 1; } if (e1.getKey() == e2.getKey()) return 0; return e1.getKey() > e2.getKey() ? 1 : -1; } }); return entries; } HMapIF(int initialCapacity, float loadFactor); HMapIF(int initialCapacity); HMapIF(); HMapIF(MapIF m); int size(); boolean isEmpty(); float get(int key); boolean containsKey(int key); float put(int key, float value); void putAll(MapIF m); float remove(int key); void clear(); boolean containsValue(float value); Object clone(); Set<Integer> keySet(); Collection<Float> values(); Set<MapIF.Entry> entrySet(); String toString(); @Override void plus(MapIF m); @Override double dot(MapIF m); @Override void increment(int key); @Override void increment(int key, float value); float length(); void normalize(); MapIF.Entry[] getEntriesSortedByValue(); MapIF.Entry[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testSortedEntries4() { HMapIF m = new HMapIF(); MapIF.Entry[] e = m.getEntriesSortedByValue(); assertTrue(e == null); }
|
### Question:
Int2FloatOpenHashMapWritable extends Int2FloatOpenHashMap implements Writable { public void increment(int key) { increment(key, 1.0f); } Int2FloatOpenHashMapWritable(); @Override void readFields(DataInput in); void decode(); boolean hasBeenDecoded(); @Override void write(DataOutput out); byte[] serialize(); static Int2FloatOpenHashMapWritable create(DataInput in); static Int2FloatOpenHashMapWritable create(byte[] bytes); void plus(Int2FloatOpenHashMapWritable m); int dot(Int2FloatOpenHashMapWritable m); void increment(int key); void increment(int key, float n); static void setLazyDecodeFlag(boolean b); static boolean getLazyDecodeFlag(); int[] getKeys(); float[] getValues(); void lazyplus(Int2FloatOpenHashMapWritable m); Int2FloatMap.Entry[] getEntriesSortedByValue(); Int2FloatMap.Entry[] getEntriesSortedByValue(int k); }### Answer:
@Test public void testIncrement() throws IOException { Int2FloatOpenHashMapWritable m = new Int2FloatOpenHashMapWritable(); m.put(2, 7.0f); m.put(1, 29.0f); assertEquals(7, m.get(2), 10e-6); assertEquals(29, m.get(1), 10e-6); m.increment(2); m.increment(1); m.increment(3); assertEquals(8, m.get(2), 10e-6); assertEquals(30, m.get(1), 10e-6); assertEquals(1, m.get(3), 10e-6); m.increment(1, 3.0f); m.increment(3, 5.0f); assertEquals(8, m.get(2), 10e-6); assertEquals(33, m.get(1), 10e-6); assertEquals(6, m.get(3), 10e-6); }
|
### Question:
Int2FloatOpenHashMapWritable extends Int2FloatOpenHashMap implements Writable { public void plus(Int2FloatOpenHashMapWritable m) { for (Int2FloatMap.Entry e : m.int2FloatEntrySet()) { int key = e.getKey(); float value = e.getValue(); if (this.containsKey(key)) { this.put(key, this.get(key) + value); } else { this.put(key, value); } } } Int2FloatOpenHashMapWritable(); @Override void readFields(DataInput in); void decode(); boolean hasBeenDecoded(); @Override void write(DataOutput out); byte[] serialize(); static Int2FloatOpenHashMapWritable create(DataInput in); static Int2FloatOpenHashMapWritable create(byte[] bytes); void plus(Int2FloatOpenHashMapWritable m); int dot(Int2FloatOpenHashMapWritable m); void increment(int key); void increment(int key, float n); static void setLazyDecodeFlag(boolean b); static boolean getLazyDecodeFlag(); int[] getKeys(); float[] getValues(); void lazyplus(Int2FloatOpenHashMapWritable m); Int2FloatMap.Entry[] getEntriesSortedByValue(); Int2FloatMap.Entry[] getEntriesSortedByValue(int k); }### Answer:
@Test public void testPlus() throws IOException { Int2FloatOpenHashMapWritable m1 = new Int2FloatOpenHashMapWritable(); m1.put(1, 5.0f); m1.put(2, 22.0f); Int2FloatOpenHashMapWritable m2 = new Int2FloatOpenHashMapWritable(); m2.put(1, 4.0f); m2.put(3, 5.0f); m1.plus(m2); assertEquals(3, m1.size(), 3); assertEquals(9.0f, m1.get(1), 10e-6); assertEquals(22.0f, m1.get(2), 10e-6); assertEquals(5.0f, m1.get(3), 10e-6); }
|
### Question:
Int2FloatOpenHashMapWritable extends Int2FloatOpenHashMap implements Writable { public int dot(Int2FloatOpenHashMapWritable m) { int s = 0; for (Int2FloatMap.Entry e : m.int2FloatEntrySet()) { int key = e.getKey(); if (this.containsKey(key)) { s += this.get(key) * e.getValue(); } } return s; } Int2FloatOpenHashMapWritable(); @Override void readFields(DataInput in); void decode(); boolean hasBeenDecoded(); @Override void write(DataOutput out); byte[] serialize(); static Int2FloatOpenHashMapWritable create(DataInput in); static Int2FloatOpenHashMapWritable create(byte[] bytes); void plus(Int2FloatOpenHashMapWritable m); int dot(Int2FloatOpenHashMapWritable m); void increment(int key); void increment(int key, float n); static void setLazyDecodeFlag(boolean b); static boolean getLazyDecodeFlag(); int[] getKeys(); float[] getValues(); void lazyplus(Int2FloatOpenHashMapWritable m); Int2FloatMap.Entry[] getEntriesSortedByValue(); Int2FloatMap.Entry[] getEntriesSortedByValue(int k); }### Answer:
@Test public void testDot() throws IOException { Int2FloatOpenHashMapWritable m1 = new Int2FloatOpenHashMapWritable(); m1.put(1, 2.0f); m1.put(2, 1.0f); m1.put(3, 3.0f); Int2FloatOpenHashMapWritable m2 = new Int2FloatOpenHashMapWritable(); m2.put(1, 1.0f); m2.put(2, 4.0f); m2.put(4, 5.0f); float s = m1.dot(m2); assertEquals(6.0f, s, 10e-6); }
|
### Question:
Int2IntOpenHashMapWritable extends Int2IntOpenHashMap implements Writable { public void plus(Int2IntOpenHashMapWritable m) { for (Int2IntMap.Entry e : m.int2IntEntrySet()) { int key = e.getIntKey(); int value = e.getIntValue(); if (this.containsKey(key)) { this.put(key, this.get(key) + value); } else { this.put(key, value); } } } Int2IntOpenHashMapWritable(); @Override void readFields(DataInput in); void decode(); boolean hasBeenDecoded(); @Override void write(DataOutput out); byte[] serialize(); static Int2IntOpenHashMapWritable create(DataInput in); static Int2IntOpenHashMapWritable create(byte[] bytes); void plus(Int2IntOpenHashMapWritable m); long dot(Int2IntOpenHashMapWritable m); void increment(int key); void increment(int key, int n); static void setLazyDecodeFlag(boolean b); static boolean getLazyDecodeFlag(); int[] getKeys(); int[] getValues(); void lazyplus(Int2IntOpenHashMapWritable m); Int2IntMap.Entry[] getEntriesSortedByValue(); Int2IntMap.Entry[] getEntriesSortedByValue(int k); }### Answer:
@Test public void testPlus() throws IOException { Int2IntOpenHashMapWritable m1 = new Int2IntOpenHashMapWritable(); m1.put(1, 5); m1.put(2, 22); Int2IntOpenHashMapWritable m2 = new Int2IntOpenHashMapWritable(); m2.put(1, 4); m2.put(3, 5); m1.plus(m2); assertEquals(3, m1.size()); assertEquals(9, m1.get(1)); assertEquals(22, m1.get(2)); assertEquals(5, m1.get(3)); }
|
### Question:
PairOfStringInt implements WritableComparable<PairOfStringInt> { public boolean equals(Object obj) { PairOfStringInt pair = (PairOfStringInt) obj; return leftElement.equals(pair.getLeftElement()) && rightElement == pair.getRightElement(); } PairOfStringInt(); PairOfStringInt(String left, int right); void readFields(DataInput in); void write(DataOutput out); String getLeftElement(); int getRightElement(); String getKey(); int getValue(); void set(String left, int right); boolean equals(Object obj); int compareTo(PairOfStringInt pair); int hashCode(); String toString(); PairOfStringInt clone(); }### Answer:
@Test public void testComparison2() throws IOException { WritableComparator comparator = new PairOfStringInt.Comparator(); PairOfStringInt pair1 = new PairOfStringInt("hi", 1); PairOfStringInt pair2 = new PairOfStringInt("hi", 1); PairOfStringInt pair3 = new PairOfStringInt("hi", 0); PairOfStringInt pair4 = new PairOfStringInt("a", 0); PairOfStringInt pair5 = new PairOfStringInt("hi", 2); assertTrue(pair1.equals(pair2)); assertFalse(pair1.equals(pair3)); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair2) == 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair3) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair4) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair5) < 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair3, pair4) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair4, pair5) < 0); }
|
### Question:
PairOfFloatString implements WritableComparable<PairOfFloatString> { @Override public boolean equals(Object obj) { PairOfFloatString pair = (PairOfFloatString) obj; return rightElement.equals(pair.getRightElement()) && leftElement == pair.getLeftElement(); } PairOfFloatString(); PairOfFloatString(float left, String right); void readFields(DataInput in); void write(DataOutput out); float getLeftElement(); String getRightElement(); String getValue(); float getKey(); void set(float left, String right); @Override boolean equals(Object obj); int compareTo(PairOfFloatString pair); @Override int hashCode(); @Override String toString(); @Override PairOfFloatString clone(); }### Answer:
@Test public void testComparison2() throws IOException { WritableComparator comparator = new PairOfFloatString.Comparator(); PairOfFloatString pair1 = new PairOfFloatString(1.0f, "hi"); PairOfFloatString pair2 = new PairOfFloatString(1.0f, "hi"); PairOfFloatString pair3 = new PairOfFloatString(0.0f, "hi"); PairOfFloatString pair4 = new PairOfFloatString(0.0f, "a"); PairOfFloatString pair5 = new PairOfFloatString(2.0f, "hi"); assertTrue(pair1.equals(pair2)); assertFalse(pair1.equals(pair3)); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair2) == 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair3) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair4) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair5) < 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair3, pair4) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair4, pair5) < 0); }
|
### Question:
PairOfStringFloat implements WritableComparable<PairOfStringFloat> { @Override public boolean equals(Object obj) { PairOfStringFloat pair = (PairOfStringFloat) obj; return leftElement.equals(pair.getLeftElement()) && rightElement == pair.getRightElement(); } PairOfStringFloat(); PairOfStringFloat(String left, float right); void readFields(DataInput in); void write(DataOutput out); String getLeftElement(); float getRightElement(); String getKey(); float getValue(); void set(String left, float right); @Override boolean equals(Object obj); int compareTo(PairOfStringFloat pair); @Override int hashCode(); @Override String toString(); @Override PairOfStringFloat clone(); }### Answer:
@Test public void testComparison2() throws IOException { WritableComparator comparator = new PairOfStringFloat.Comparator(); PairOfStringFloat pair1 = new PairOfStringFloat("hi", 1.0f); PairOfStringFloat pair2 = new PairOfStringFloat("hi", 1.0f); PairOfStringFloat pair3 = new PairOfStringFloat("hi", 0.0f); PairOfStringFloat pair4 = new PairOfStringFloat("a", 0.0f); PairOfStringFloat pair5 = new PairOfStringFloat("hi", 2.0f); assertTrue(pair1.equals(pair2)); assertFalse(pair1.equals(pair3)); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair2) == 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair3) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair4) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair5) < 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair3, pair4) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair4, pair5) < 0); }
|
### Question:
PairOfStringLong implements WritableComparable<PairOfStringLong> { public boolean equals(Object obj) { PairOfStringLong pair = (PairOfStringLong) obj; return leftElement.equals(pair.getLeftElement()) && rightElement == pair.getRightElement(); } PairOfStringLong(); PairOfStringLong(String left, long right); void readFields(DataInput in); void write(DataOutput out); String getLeftElement(); long getRightElement(); String getKey(); long getValue(); void set(String left, long right); boolean equals(Object obj); int compareTo(PairOfStringLong pair); int hashCode(); String toString(); PairOfStringLong clone(); }### Answer:
@Test public void testComparison2() throws IOException { WritableComparator comparator = new PairOfStringLong.Comparator(); PairOfStringLong pair1 = new PairOfStringLong("hi", 1L); PairOfStringLong pair2 = new PairOfStringLong("hi", 1L); PairOfStringLong pair3 = new PairOfStringLong("hi", 0L); PairOfStringLong pair4 = new PairOfStringLong("a", 0L); PairOfStringLong pair5 = new PairOfStringLong("hi", 2L); assertTrue(pair1.equals(pair2)); assertFalse(pair1.equals(pair3)); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair2) == 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair3) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair4) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair5) < 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair3, pair4) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair4, pair5) < 0); }
|
### Question:
PairOfLongString implements WritableComparable<PairOfLongString> { @Override public boolean equals(Object obj) { PairOfLongString pair = (PairOfLongString) obj; return rightElement.equals(pair.getRightElement()) && leftElement == pair.getLeftElement(); } PairOfLongString(); PairOfLongString(long left, String right); void readFields(DataInput in); void write(DataOutput out); long getLeftElement(); String getRightElement(); String getValue(); long getKey(); void set(long left, String right); @Override boolean equals(Object obj); int compareTo(PairOfLongString pair); @Override int hashCode(); @Override String toString(); @Override PairOfLongString clone(); }### Answer:
@Test public void testComparison2() throws IOException { WritableComparator comparator = new PairOfLongString.Comparator(); PairOfLongString pair1 = new PairOfLongString(1L, "hi"); PairOfLongString pair2 = new PairOfLongString(1L, "hi"); PairOfLongString pair3 = new PairOfLongString(0L, "hi"); PairOfLongString pair4 = new PairOfLongString(0L, "a"); PairOfLongString pair5 = new PairOfLongString(2L, "hi"); assertTrue(pair1.equals(pair2)); assertFalse(pair1.equals(pair3)); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair2) == 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair3) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair4) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair5) < 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair3, pair4) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair4, pair5) < 0); }
|
### Question:
PairOfStrings implements WritableComparable<PairOfStrings> { public boolean equals(Object obj) { PairOfStrings pair = (PairOfStrings) obj; return leftElement.equals(pair.getLeftElement()) && rightElement.equals(pair.getRightElement()); } PairOfStrings(); PairOfStrings(String left, String right); void readFields(DataInput in); void write(DataOutput out); String getLeftElement(); String getRightElement(); String getKey(); String getValue(); void set(String left, String right); boolean equals(Object obj); int compareTo(PairOfStrings pair); int hashCode(); String toString(); PairOfStrings clone(); }### Answer:
@Test public void testComparison2() throws IOException { WritableComparator comparator = new PairOfStrings.Comparator(); PairOfStrings pair1 = new PairOfStrings("hi", "there"); PairOfStrings pair2 = new PairOfStrings("hi", "there"); PairOfStrings pair3 = new PairOfStrings("hi", "howdy"); PairOfStrings pair4 = new PairOfStrings("a", "howdy"); PairOfStrings pair5 = new PairOfStrings("hi", "z"); assertTrue(pair1.equals(pair2)); assertFalse(pair1.equals(pair3)); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair2) == 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair3) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair4) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair1, pair5) < 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair3, pair4) > 0); assertTrue(WritableComparatorTestHarness.compare(comparator, pair4, pair5) < 0); }
|
### Question:
PairOfStrings implements WritableComparable<PairOfStrings> { public int hashCode() { return Objects.hash(leftElement, rightElement); } PairOfStrings(); PairOfStrings(String left, String right); void readFields(DataInput in); void write(DataOutput out); String getLeftElement(); String getRightElement(); String getKey(); String getValue(); void set(String left, String right); boolean equals(Object obj); int compareTo(PairOfStrings pair); int hashCode(); String toString(); PairOfStrings clone(); }### Answer:
@Test public void testHashCode() throws IOException { PairOfStrings pair1 = new PairOfStrings("hi", "there"); PairOfStrings pair2 = new PairOfStrings("there", "hi"); PairOfStrings pair3 = new PairOfStrings("hello", "world"); HashSet<PairOfStrings> hash = new HashSet<PairOfStrings>(); assertTrue(hash.add(pair1)); assertFalse(hash.add(pair1)); assertTrue(hash.add(pair2)); assertFalse(hash.add(pair2)); assertTrue(hash.add(pair3)); assertTrue(hash.remove(pair3)); assertTrue(hash.remove(pair1)); assertTrue(hash.remove(pair2)); }
|
### Question:
ArrayListWritableComparable extends ArrayList<E> implements WritableComparable<ArrayListWritableComparable<E>> { public String toString() { StringBuffer sb = new StringBuffer(); sb.append("["); for (int i = 0; i < this.size(); i++) { if (i != 0) sb.append(", "); sb.append(this.get(i)); } sb.append("]"); return sb.toString(); } ArrayListWritableComparable(); ArrayListWritableComparable(ArrayList<E> array); void readFields(DataInput in); void write(DataOutput out); int compareTo(ArrayListWritableComparable<E> obj); String toString(); }### Answer:
@Test public void testBasic() throws IOException { ArrayListWritableComparable<Text> list = new ArrayListWritableComparable<Text>(); list.add(new Text("hi")); list.add(new Text("there")); assertEquals(list.get(0).toString(), "hi"); assertEquals(list.get(1).toString(), "there"); }
@Test public void testToString() { ArrayListWritableComparable<Text> list = new ArrayListWritableComparable<Text>(); list.add(new Text("hi")); list.add(new Text("there")); assertEquals(list.toString(), "[hi, there]"); }
|
### Question:
ArrayListOfLongsWritable extends ArrayListOfLongs implements
WritableComparable<ArrayListOfLongsWritable> { @Override public String toString() { return toString(size()); } ArrayListOfLongsWritable(); ArrayListOfLongsWritable(int initialCapacity); ArrayListOfLongsWritable(int first, int last); ArrayListOfLongsWritable(ArrayListOfLongsWritable other); ArrayListOfLongsWritable(long[] arr); void readFields(DataInput in); void write(DataOutput out); @Override String toString(); static ArrayListOfLongsWritable fromArrayListOfLongs(ArrayListOfLongs a); @Override int compareTo(ArrayListOfLongsWritable obj); }### Answer:
@Test public void testToString() { assertEquals("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", new ArrayListOfLongsWritable(1, 11).toString()); assertEquals("[1, 2, 3, 4, 5 ... (5 more) ]", new ArrayListOfLongsWritable(1, 11).toString(5)); assertEquals("[1, 2, 3, 4, 5]", new ArrayListOfLongsWritable(1, 6).toString()); assertEquals("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]", new ArrayListOfLongsWritable(1, 12).toString()); assertEquals("[]", new ArrayListOfLongsWritable().toString()); }
|
### Question:
Int2IntOpenHashMapWritable extends Int2IntOpenHashMap implements Writable { public long dot(Int2IntOpenHashMapWritable m) { int s = 0; for (Int2IntMap.Entry e : m.int2IntEntrySet()) { int key = e.getIntKey(); if (this.containsKey(key)) { s += this.get(key) * e.getIntValue(); } } return s; } Int2IntOpenHashMapWritable(); @Override void readFields(DataInput in); void decode(); boolean hasBeenDecoded(); @Override void write(DataOutput out); byte[] serialize(); static Int2IntOpenHashMapWritable create(DataInput in); static Int2IntOpenHashMapWritable create(byte[] bytes); void plus(Int2IntOpenHashMapWritable m); long dot(Int2IntOpenHashMapWritable m); void increment(int key); void increment(int key, int n); static void setLazyDecodeFlag(boolean b); static boolean getLazyDecodeFlag(); int[] getKeys(); int[] getValues(); void lazyplus(Int2IntOpenHashMapWritable m); Int2IntMap.Entry[] getEntriesSortedByValue(); Int2IntMap.Entry[] getEntriesSortedByValue(int k); }### Answer:
@Test public void testDot() throws IOException { Int2IntOpenHashMapWritable m1 = new Int2IntOpenHashMapWritable(); m1.put(1, 2); m1.put(2, 1); m1.put(3, 3); Int2IntOpenHashMapWritable m2 = new Int2IntOpenHashMapWritable(); m2.put(1, 1); m2.put(2, 4); m2.put(4, 5); long s = m1.dot(m2); assertEquals(6, s); }
|
### Question:
ArrayListOfFloats implements RandomAccess, Cloneable, Iterable<Float> { public int size() { return size; } ArrayListOfFloats(int initialCapacity); ArrayListOfFloats(); ArrayListOfFloats(float[] a); ArrayListOfFloats(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(float n); int indexOf(float n); int lastIndexOf(float n); ArrayListOfFloats clone(); float get(int index); float set(int index, float element); ArrayListOfFloats add(float e); ArrayListOfFloats add(int index, float element); float remove(int index); void clear(); float[] getArray(); Iterator<Float> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfFloats intersection(ArrayListOfFloats other); ArrayListOfFloats merge(ArrayListOfFloats sortedLst); ArrayListOfFloats subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testInitialSize() { ArrayListOfFloats a = new ArrayListOfFloats(); assertEquals(0, a.size()); }
|
### Question:
ArrayListOfFloats implements RandomAccess, Cloneable, Iterable<Float> { public ArrayListOfFloats add(float e) { ensureCapacity(size + 1); array[size++] = e; return this; } ArrayListOfFloats(int initialCapacity); ArrayListOfFloats(); ArrayListOfFloats(float[] a); ArrayListOfFloats(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(float n); int indexOf(float n); int lastIndexOf(float n); ArrayListOfFloats clone(); float get(int index); float set(int index, float element); ArrayListOfFloats add(float e); ArrayListOfFloats add(int index, float element); float remove(int index); void clear(); float[] getArray(); Iterator<Float> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfFloats intersection(ArrayListOfFloats other); ArrayListOfFloats merge(ArrayListOfFloats sortedLst); ArrayListOfFloats subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testIterable() { int size = 1000; Random r = new Random(); float[] floats = new float[size]; ArrayListOfFloats list = new ArrayListOfFloats(); for (int i = 0; i < size; i++) { float k = r.nextFloat(); list.add(k); floats[i] = k; } int i = 0; for (Float v : list) { assertEquals(floats[i++], v, 10e-5); } }
|
### Question:
ArrayListOfFloats implements RandomAccess, Cloneable, Iterable<Float> { public void setSize(int sz) { ensureCapacity(sz); size = sz; } ArrayListOfFloats(int initialCapacity); ArrayListOfFloats(); ArrayListOfFloats(float[] a); ArrayListOfFloats(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(float n); int indexOf(float n); int lastIndexOf(float n); ArrayListOfFloats clone(); float get(int index); float set(int index, float element); ArrayListOfFloats add(float e); ArrayListOfFloats add(int index, float element); float remove(int index); void clear(); float[] getArray(); Iterator<Float> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfFloats intersection(ArrayListOfFloats other); ArrayListOfFloats merge(ArrayListOfFloats sortedLst); ArrayListOfFloats subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testSetSize() { ArrayListOfFloats list = new ArrayListOfFloats(); list.add(5.0f); assertEquals(1, list.size); assertEquals(5.0f, list.get(0), 10e-6); list.setSize(5); assertEquals(5, list.size); assertEquals(0.0f, list.get(1), 10e-6); assertEquals(0.0f, list.get(2), 10e-6); assertEquals(0.0f, list.get(3), 10e-6); assertEquals(0.0f, list.get(4), 10e-6); list.add(12.0f); assertEquals(6, list.size); assertEquals(12.0f, list.get(5), 10e-6); }
|
### Question:
ArrayListOfFloats implements RandomAccess, Cloneable, Iterable<Float> { public void sort() { trimToSize(); Arrays.sort(getArray()); } ArrayListOfFloats(int initialCapacity); ArrayListOfFloats(); ArrayListOfFloats(float[] a); ArrayListOfFloats(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(float n); int indexOf(float n); int lastIndexOf(float n); ArrayListOfFloats clone(); float get(int index); float set(int index, float element); ArrayListOfFloats add(float e); ArrayListOfFloats add(int index, float element); float remove(int index); void clear(); float[] getArray(); Iterator<Float> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfFloats intersection(ArrayListOfFloats other); ArrayListOfFloats merge(ArrayListOfFloats sortedLst); ArrayListOfFloats subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testSort() { ArrayListOfFloats a = new ArrayListOfFloats(); assertEquals(0, a.size()); a.add(5.2f).add(6f).add(5.9f).add(4.1f); assertEquals(4, a.size()); a.sort(); assertEquals(4, a.size()); assertTrue(Math.abs(a.get(0) - 4.1) < 0.0001); assertTrue(Math.abs(a.get(1) - 5.2) < 0.0001); assertTrue(Math.abs(a.get(2) - 5.9) < 0.0001); assertTrue(Math.abs(a.get(3) - 6) < 0.0001); }
|
### Question:
ArrayListOfFloats implements RandomAccess, Cloneable, Iterable<Float> { public void addUnique(int[] arr) { for (int i = 0; i < arr.length; i++) { int elt = arr[i]; if (!contains(elt)) { add(elt); } } } ArrayListOfFloats(int initialCapacity); ArrayListOfFloats(); ArrayListOfFloats(float[] a); ArrayListOfFloats(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(float n); int indexOf(float n); int lastIndexOf(float n); ArrayListOfFloats clone(); float get(int index); float set(int index, float element); ArrayListOfFloats add(float e); ArrayListOfFloats add(int index, float element); float remove(int index); void clear(); float[] getArray(); Iterator<Float> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfFloats intersection(ArrayListOfFloats other); ArrayListOfFloats merge(ArrayListOfFloats sortedLst); ArrayListOfFloats subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testAddUnique() { ArrayListOfFloats a = new ArrayListOfFloats(new float[] { 1, 2, 3, 4, 5, 6, 7 }); a.addUnique(new int[] { 8, 0, 2, 5, -1, 11, 9 }); assertEquals(12, a.size()); assertTrue(Math.abs(0 - a.get(8)) < 0.0001); assertTrue(Math.abs(-1 - a.get(9)) < 0.0001); assertTrue(Math.abs(11 - a.get(10)) < 0.0001); assertTrue(Math.abs(9 - a.get(11)) < 0.0001); }
|
### Question:
ArrayListOfIntsWritable extends ArrayListOfInts implements
WritableComparable<ArrayListOfIntsWritable> { @Override public String toString() { return toString(size()); } ArrayListOfIntsWritable(); ArrayListOfIntsWritable(int initialCapacity); ArrayListOfIntsWritable(int first, int last); ArrayListOfIntsWritable(ArrayListOfIntsWritable other); ArrayListOfIntsWritable(int[] arr); void readFields(DataInput in); void write(DataOutput out); @Override String toString(); static ArrayListOfIntsWritable fromArrayListOfInts(ArrayListOfInts a); @Override int compareTo(ArrayListOfIntsWritable obj); }### Answer:
@Test public void testToString() { assertEquals("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", new ArrayListOfIntsWritable(1, 11).toString()); assertEquals("[1, 2, 3, 4, 5 ... (5 more) ]", new ArrayListOfIntsWritable(1, 11).toString(5)); assertEquals("[1, 2, 3, 4, 5]", new ArrayListOfIntsWritable(1, 6).toString()); assertEquals("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]", new ArrayListOfIntsWritable(1, 12).toString()); assertEquals("[]", new ArrayListOfIntsWritable().toString()); }
|
### Question:
ArrayListOfInts implements RandomAccess, Cloneable, Iterable<Integer> { public int size() { return size; } ArrayListOfInts(int initialCapacity); ArrayListOfInts(); ArrayListOfInts(int[] a); ArrayListOfInts(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(int n); int indexOf(int n); int lastIndexOf(int n); ArrayListOfInts clone(); int get(int index); int set(int index, int element); ArrayListOfInts add(int e); ArrayListOfInts add(int index, int element); int remove(int index); void clear(); int[] getArray(); Iterator<Integer> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfInts intersection(ArrayListOfInts other); ArrayListOfInts merge(ArrayListOfInts sortedLst); ArrayListOfInts mergeNoDuplicates(ArrayListOfInts sortedLst); ArrayListOfInts subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testInitialSize() { ArrayListOfInts a = new ArrayListOfInts(); assertEquals(0, a.size()); }
|
### Question:
ArrayListOfInts implements RandomAccess, Cloneable, Iterable<Integer> { public ArrayListOfInts add(int e) { ensureCapacity(size + 1); array[size++] = e; return this; } ArrayListOfInts(int initialCapacity); ArrayListOfInts(); ArrayListOfInts(int[] a); ArrayListOfInts(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(int n); int indexOf(int n); int lastIndexOf(int n); ArrayListOfInts clone(); int get(int index); int set(int index, int element); ArrayListOfInts add(int e); ArrayListOfInts add(int index, int element); int remove(int index); void clear(); int[] getArray(); Iterator<Integer> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfInts intersection(ArrayListOfInts other); ArrayListOfInts merge(ArrayListOfInts sortedLst); ArrayListOfInts mergeNoDuplicates(ArrayListOfInts sortedLst); ArrayListOfInts subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testIterable() { int size = 1000; Random r = new Random(); int[] ints = new int[size]; ArrayListOfInts list = new ArrayListOfInts(); for (int i = 0; i < size; i++) { int k = r.nextInt(size); list.add(k); ints[i] = k; } int i = 0; for (Integer v : list) { assertEquals(ints[i++], (int) v); } }
|
### Question:
ArrayListOfInts implements RandomAccess, Cloneable, Iterable<Integer> { public void setSize(int sz) { ensureCapacity(sz); size = sz; } ArrayListOfInts(int initialCapacity); ArrayListOfInts(); ArrayListOfInts(int[] a); ArrayListOfInts(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(int n); int indexOf(int n); int lastIndexOf(int n); ArrayListOfInts clone(); int get(int index); int set(int index, int element); ArrayListOfInts add(int e); ArrayListOfInts add(int index, int element); int remove(int index); void clear(); int[] getArray(); Iterator<Integer> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfInts intersection(ArrayListOfInts other); ArrayListOfInts merge(ArrayListOfInts sortedLst); ArrayListOfInts mergeNoDuplicates(ArrayListOfInts sortedLst); ArrayListOfInts subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testSetSize() { ArrayListOfInts list = new ArrayListOfInts(); list.add(5); assertEquals(1, list.size); assertEquals(5, list.get(0)); list.setSize(5); assertEquals(5, list.size); assertEquals(0, list.get(1)); assertEquals(0, list.get(2)); assertEquals(0, list.get(3)); assertEquals(0, list.get(4)); list.add(12); assertEquals(6, list.size); assertEquals(12, list.get(5)); }
|
### Question:
ArrayListOfInts implements RandomAccess, Cloneable, Iterable<Integer> { public void sort() { trimToSize(); Arrays.sort(getArray()); } ArrayListOfInts(int initialCapacity); ArrayListOfInts(); ArrayListOfInts(int[] a); ArrayListOfInts(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(int n); int indexOf(int n); int lastIndexOf(int n); ArrayListOfInts clone(); int get(int index); int set(int index, int element); ArrayListOfInts add(int e); ArrayListOfInts add(int index, int element); int remove(int index); void clear(); int[] getArray(); Iterator<Integer> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfInts intersection(ArrayListOfInts other); ArrayListOfInts merge(ArrayListOfInts sortedLst); ArrayListOfInts mergeNoDuplicates(ArrayListOfInts sortedLst); ArrayListOfInts subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testSort() { ArrayListOfInts a = new ArrayListOfInts(); assertEquals(0, a.size()); a.add(5).add(6).add(1).add(4); assertEquals(4, a.size()); a.sort(); assertEquals(4, a.size()); assertEquals(1, a.get(0)); assertEquals(4, a.get(1)); assertEquals(5, a.get(2)); assertEquals(6, a.get(3)); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.