method2testcases
stringlengths 118
6.63k
|
|---|
### 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:
Sh1106 implements Closeable { public void setContrast(int level) throws IOException, IllegalArgumentException { if (mI2cDevice == null) { throw new IllegalStateException("I2C Device not open"); } if (level < 0 || level > 255) { throw new IllegalArgumentException("Invalid contrast " + String.valueOf(level) + ", level must be between 0 and 255"); } mI2cDevice.writeRegByte(0, (byte) COMMAND_CONTRAST_LEVEL); mI2cDevice.writeRegByte(0, (byte) level); } Sh1106(String i2cName); Sh1106(String i2cName, int width, int height); Sh1106(String i2cName, int i2cAddress); Sh1106(String i2cName, int i2cAddress, int width, int height); Sh1106(I2cDevice device); @Override void close(); int getLcdWidth(); int getLcdHeight(); void clearPixels(); void setPixel(int x, int y, boolean on); void setContrast(int level); void setDisplayOn(boolean on); void setInvertDisplay(boolean invert); void show(); static final int I2C_ADDRESS; static final int I2C_ADDRESS_ALT; }### Answer:
@Test public void setContrastValidValues() throws IOException { mockStatic(BitmapHelper.class); mockStatic(Bitmap.class); Sh1106 sh1106 = new Sh1106(mI2c); int[] validValues = {0, 66, 255}; for (int validValue : validValues) { sh1106.setContrast(validValue); Mockito.verify(mI2c).writeRegByte(0x00, (byte) 0x81); Mockito.verify(mI2c).writeRegByte(0x00, (byte) validValue); Mockito.reset(mI2c); } }
@Test public void setContrastInValidValues() throws IOException { int[] invalidValues = {-777, -1, 256, 999}; mockStatic(BitmapHelper.class); mockStatic(Bitmap.class); Sh1106 sh1106 = new Sh1106(mI2c); for (int invalidValue : invalidValues) { mExpectedException.expect(IllegalArgumentException.class); mExpectedException.expectMessage("Invalid contrast " + String.valueOf(invalidValue) + ", level must be " + "between 0 and 255"); sh1106.setContrast(invalidValue); Mockito.verify(mI2c, Mockito.never()).writeRegByte(0x00, (byte) 0x81); Mockito.verify(mI2c, Mockito.never()).writeRegByte(0x00, (byte) 66); Mockito.reset(mExpectedException); } }
@Test public void nullmI2cDevice() throws IOException { Sh1106 sh1106 = mock(Sh1106.class, withSettings().defaultAnswer(CALLS_REAL_METHODS)); mExpectedException.expect(IllegalStateException.class); mExpectedException.expectMessage("I2C Device not open"); sh1106.setContrast(44); }
|
### 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 { public MapII.Entry[] getEntriesSortedByValue() { if (this.size() == 0) return null; MapII.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<MapII.Entry>() { public int compare(MapII.Entry e1, MapII.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; } 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 testSortedEntries4() { HMapII m = new HMapII(); MapII.Entry[] e = m.getEntriesSortedByValue(); assertTrue(e == null); }
|
### 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:
Int2LongOpenHashMapWritable extends Int2LongOpenHashMap implements Writable { public void lazyplus(Int2LongOpenHashMapWritable m) { int[] k = m.getKeys(); long[] v = m.getValues(); for (int i = 0; i < k.length; i++) { if (this.containsKey(k[i])) { this.put(k[i], this.get(k[i]) + v[i]); } else { this.put(k[i], v[i]); } } } 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 testLazyPlus() throws IOException { Int2LongOpenHashMapWritable m1 = new Int2LongOpenHashMapWritable(); m1.put(1, 5L); m1.put(2, 22L); Int2LongOpenHashMapWritable m2 = new Int2LongOpenHashMapWritable(); m2.put(1, 4L); m2.put(3, 5L); Int2LongOpenHashMapWritable.setLazyDecodeFlag(true); Int2LongOpenHashMapWritable m3 = Int2LongOpenHashMapWritable.create(m2.serialize()); assertEquals(0, m3.size()); m1.lazyplus(m3); assertEquals(3, m1.size()); assertEquals(9L, m1.get(1)); assertEquals(22L, m1.get(2)); assertEquals(5L, m1.get(3)); Int2LongOpenHashMapWritable.setLazyDecodeFlag(false); }
|
### 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 plus(MapKI<K> m) { for (MapKI.Entry<K> e : m.entrySet()) { K key = e.getKey(); if (this.containsKey(key)) { this.put(key, this.get(key) + e.getValue()); } else { this.put(key, e.getValue()); } } } @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 testPlus() throws IOException { HMapKI<Text> m1 = new HMapKI<Text>(); m1.put(new Text("hi"), 5); m1.put(new Text("there"), 22); HMapKI<Text> m2 = new HMapKI<Text>(); m2.put(new Text("hi"), 4); m2.put(new Text("test"), 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:
HMapKI implements MapKI<K>, Cloneable, Serializable { @Override public long dot(MapKI<K> m) { int s = 0; for (MapKI.Entry<K> e : m.entrySet()) { K key = e.getKey(); if (this.containsKey(key)) { s += this.get(key) * e.getValue(); } } return s; } @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 testDot() throws IOException { HMapKI<Text> m1 = new HMapKI<Text>(); m1.put(new Text("hi"), 5); m1.put(new Text("there"), 2); m1.put(new Text("empty"), 3); HMapKI<Text> m2 = new HMapKI<Text>(); m2.put(new Text("hi"), 4); m2.put(new Text("there"), 4); m2.put(new Text("test"), 5); assertEquals(28, m1.dot(m2)); }
|
### 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:
HMapKI implements MapKI<K>, Cloneable, Serializable { @Override public String toString() { Iterator<MapKI.Entry<K>> i = entrySet().iterator(); if (!i.hasNext()) return "{}"; StringBuilder sb = new StringBuilder(); sb.append('{'); for (;;) { MapKI.Entry<K> e = i.next(); K key = e.getKey(); int value = e.getValue(); sb.append(key); sb.append('='); sb.append(value); if (!i.hasNext()) return sb.append('}').toString(); sb.append(", "); } } @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 testToString() throws IOException { HMapKI<String> m1 = new HMapKI<String>(); m1.put("hi", 5); m1.put("there", 22); assertEquals("{there=22, hi=5}", m1.toString()); }
|
### 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:
HMapIL implements MapIL, Cloneable, Serializable { @Override public void plus(MapIL m) { for (MapIL.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()); } } } 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 testPlus() throws IOException { HMapIL m1 = new HMapIL(); m1.put(1, Integer.MAX_VALUE + 5L); m1.put(2, Integer.MAX_VALUE + 22L); m1.put(Integer.MAX_VALUE, Integer.MAX_VALUE); HMapIL m2 = new HMapIL(); m2.put(1, 4L); m2.put(3, Integer.MAX_VALUE + 5L); m2.put(Integer.MAX_VALUE, Integer.MAX_VALUE); m1.plus(m2); assertEquals(m1.size(), 4); assertTrue(m1.get(1) == Integer.MAX_VALUE + 9L); assertTrue(m1.get(2) == Integer.MAX_VALUE + 22L); assertTrue(m1.get(3) == Integer.MAX_VALUE + 5L); assertTrue(m1.get(Integer.MAX_VALUE) == 2L * Integer.MAX_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:
HMapIL implements MapIL, Cloneable, Serializable { public MapIL.Entry[] getEntriesSortedByValue() { if (this.size() == 0) return null; MapIL.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<MapIL.Entry>() { public int compare(MapIL.Entry e1, MapIL.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; } 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 testSortedEntries4() { HMapIL m = new HMapIL(); MapIL.Entry[] e = m.getEntriesSortedByValue(); assertTrue(e == null); }
|
### Question:
HMapKF implements MapKF<K>, Cloneable, Serializable { @Override public void plus(MapKF<K> m) { for (MapKF.Entry<K> e : m.entrySet()) { K key = e.getKey(); if (this.containsKey(key)) { this.put(key, this.get(key) + e.getValue()); } else { this.put(key, e.getValue()); } } } @SuppressWarnings("unchecked") HMapKF(int initialCapacity, float loadFactor); HMapKF(int initialCapacity); @SuppressWarnings("unchecked") HMapKF(); HMapKF(MapKF<? extends K> m); int size(); boolean isEmpty(); float get(K key); boolean containsKey(K key); float put(K key, float value); void putAll(MapKF<? extends K> m); float remove(K key); void clear(); boolean containsValue(float value); @SuppressWarnings("unchecked") Object clone(); Set<K> keySet(); Collection<Float> values(); Set<MapKF.Entry<K>> entrySet(); String toString(); @Override void plus(MapKF<K> m); @Override double dot(MapKF<K> m); @Override void increment(K key); @Override void increment(K key, float value); float length(); void normalize(); @SuppressWarnings("unchecked") MapKF.Entry<K>[] getEntriesSortedByValue(); MapKF.Entry<K>[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testPlus() throws IOException { HMapKF<Text> m1 = new HMapKF<Text>(); m1.put(new Text("hi"), 5.0f); m1.put(new Text("there"), 22.0f); HMapKF<Text> m2 = new HMapKF<Text>(); m2.put(new Text("hi"), 4.0f); m2.put(new Text("test"), 5.0f); m1.plus(m2); assertEquals(m1.size(), 3); assertTrue(m1.get(new Text("hi")) == 9); assertTrue(m1.get(new Text("there")) == 22); assertTrue(m1.get(new Text("test")) == 5); }
|
### Question:
HMapKF implements MapKF<K>, Cloneable, Serializable { @Override public double dot(MapKF<K> m) { double s = 0.0f; for (MapKF.Entry<K> e : m.entrySet()) { K key = e.getKey(); if (this.containsKey(key)) { s += this.get(key) * e.getValue(); } } return s; } @SuppressWarnings("unchecked") HMapKF(int initialCapacity, float loadFactor); HMapKF(int initialCapacity); @SuppressWarnings("unchecked") HMapKF(); HMapKF(MapKF<? extends K> m); int size(); boolean isEmpty(); float get(K key); boolean containsKey(K key); float put(K key, float value); void putAll(MapKF<? extends K> m); float remove(K key); void clear(); boolean containsValue(float value); @SuppressWarnings("unchecked") Object clone(); Set<K> keySet(); Collection<Float> values(); Set<MapKF.Entry<K>> entrySet(); String toString(); @Override void plus(MapKF<K> m); @Override double dot(MapKF<K> m); @Override void increment(K key); @Override void increment(K key, float value); float length(); void normalize(); @SuppressWarnings("unchecked") MapKF.Entry<K>[] getEntriesSortedByValue(); MapKF.Entry<K>[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testDot() throws IOException { HMapKF<Text> m1 = new HMapKF<Text>(); m1.put(new Text("hi"), 2.3f); m1.put(new Text("there"), 1.9f); m1.put(new Text("empty"), 3.0f); HMapKF<Text> m2 = new HMapKF<Text>(); m2.put(new Text("hi"), 1.2f); m2.put(new Text("there"), 4.3f); m2.put(new Text("test"), 5.0f); assertEquals(10.93, m1.dot(m2), 10e-6); }
|
### Question:
HMapKF implements MapKF<K>, Cloneable, Serializable { @Override public void increment(K key) { if (this.containsKey(key)) { this.put(key, (float) this.get(key) + 1.0f); } else { this.put(key, 1.0f); } } @SuppressWarnings("unchecked") HMapKF(int initialCapacity, float loadFactor); HMapKF(int initialCapacity); @SuppressWarnings("unchecked") HMapKF(); HMapKF(MapKF<? extends K> m); int size(); boolean isEmpty(); float get(K key); boolean containsKey(K key); float put(K key, float value); void putAll(MapKF<? extends K> m); float remove(K key); void clear(); boolean containsValue(float value); @SuppressWarnings("unchecked") Object clone(); Set<K> keySet(); Collection<Float> values(); Set<MapKF.Entry<K>> entrySet(); String toString(); @Override void plus(MapKF<K> m); @Override double dot(MapKF<K> m); @Override void increment(K key); @Override void increment(K key, float value); float length(); void normalize(); @SuppressWarnings("unchecked") MapKF.Entry<K>[] getEntriesSortedByValue(); MapKF.Entry<K>[] getEntriesSortedByValue(int n); }### Answer:
@Test public void testIncrement() { HMapKF<String> m = new HMapKF<String>(); assertEquals(0.0f, m.get("one"), 10E-6); m.increment("one", 0.5f); assertEquals(0.5f, m.get("one"), 10E-6); m.increment("one", 1.0f); m.increment("two", 0.0f); m.increment("three", -0.5f); assertEquals(1.5f, m.get("one"), 10E-6); assertEquals(0.0f, m.get("two"), 10E-6); assertEquals(-0.5f, m.get("three"), 10E-6); }
|
### 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:
Int2LongOpenHashMapWritable extends Int2LongOpenHashMap implements Writable { public Int2LongMap.Entry[] getEntriesSortedByValue() { if (this.size() == 0) return null; Int2LongMap.Entry[] entries = new Int2LongMap.Entry[this.size()]; entries = this.int2LongEntrySet().toArray(entries); Arrays.sort(entries, new Comparator<Int2LongMap.Entry>() { public int compare(Int2LongMap.Entry e1, Int2LongMap.Entry e2) { if (e1.getLongValue() > e2.getLongValue()) { return -1; } else if (e1.getLongValue() < e2.getLongValue()) { return 1; } if (e1.getIntKey() == e2.getIntKey()) return 0; return e1.getIntKey() > e2.getIntKey() ? 1 : -1; } }); return entries; } 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 testSortedEntries1() { Int2LongOpenHashMapWritable m = new Int2LongOpenHashMapWritable(); m.put(1, 5L); m.put(2, 2L); m.put(3, 3L); m.put(4, 3L); m.put(5, 1L); Int2LongMap.Entry[] e = m.getEntriesSortedByValue(); assertEquals(5, e.length); assertEquals(1, e[0].getIntKey()); assertEquals(5L, e[0].getLongValue()); assertEquals(3, e[1].getIntKey()); assertEquals(3L, e[1].getLongValue()); assertEquals(4, e[2].getIntKey()); assertEquals(3L, e[2].getLongValue()); assertEquals(2, e[3].getIntKey()); assertEquals(2L, e[3].getLongValue()); assertEquals(5, e[4].getIntKey()); assertEquals(1L, e[4].getLongValue()); }
@Test public void testSortedEntries2() { Int2LongOpenHashMapWritable m = new Int2LongOpenHashMapWritable(); m.put(1, 5); m.put(2, 2); m.put(3, 3); m.put(4, 3); m.put(5, 1); Int2LongMap.Entry[] e = m.getEntriesSortedByValue(2); assertEquals(2, e.length); assertEquals(1, e[0].getIntKey()); assertEquals(5L, e[0].getLongValue()); assertEquals(3, e[1].getIntKey()); assertEquals(3L, e[1].getLongValue()); }
@Test public void testSortedEntries3() { Int2LongOpenHashMapWritable m = new Int2LongOpenHashMapWritable(); m.put(1, 5); m.put(2, 2); Int2LongMap.Entry[] e = m.getEntriesSortedByValue(5); assertEquals(2, e.length); assertEquals(1, e[0].getIntKey()); assertEquals(5L, e[0].getLongValue()); assertEquals(2, e[1].getIntKey()); assertEquals(2L, e[1].getLongValue()); }
@Test public void testSortedEntries4() { Int2LongOpenHashMapWritable m = new Int2LongOpenHashMapWritable(); Int2LongMap.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:
HMapIS implements MapIS, Cloneable, Serializable { public MapIS.Entry[] getEntriesSortedByValue() { if (this.size() == 0) return null; MapIS.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<MapIS.Entry>() { public int compare(MapIS.Entry e1, MapIS.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; } 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 testSortedEntries4() { HMapIS m = new HMapIS(); MapIS.Entry[] e = m.getEntriesSortedByValue(); assertTrue(e == null); }
|
### Question:
HMapKL implements MapKL<K>, Cloneable, Serializable { @Override public void plus(MapKL<K> m) { for (MapKL.Entry<K> e : m.entrySet()) { K key = e.getKey(); if (this.containsKey(key)) { this.put(key, (long) (this.get(key) + e.getValue())); } else { this.put(key, e.getValue()); } } } @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 testPlus() throws IOException { HMapKL<String> m1 = new HMapKL<String>(); m1.put("1", Integer.MAX_VALUE + 5L); m1.put("2", Integer.MAX_VALUE + 22L); m1.put("" + Integer.MAX_VALUE, Integer.MAX_VALUE); HMapKL<String> m2 = new HMapKL<String>(); m2.put("1", 4L); m2.put("3", Integer.MAX_VALUE + 5L); m2.put("" + Integer.MAX_VALUE, Integer.MAX_VALUE); m1.plus(m2); assertEquals(m1.size(), 4); assertTrue(m1.get("1") == Integer.MAX_VALUE + 9L); assertTrue(m1.get("2") == Integer.MAX_VALUE + 22L); assertTrue(m1.get("3") == Integer.MAX_VALUE + 5L); assertTrue(m1.get("" + Integer.MAX_VALUE) == 2L * Integer.MAX_VALUE); }
|
### 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 void lazyplus(Int2FloatOpenHashMapWritable m) { int[] keys = m.getKeys(); float[] values = m.getValues(); for (int i = 0; i < keys.length; i++) { if (this.containsKey(keys[i])) { this.put(keys[i], this.get(keys[i]) + values[i]); } else { this.put(keys[i], values[i]); } } } 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 testLazyPlus() 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); Int2FloatOpenHashMapWritable.setLazyDecodeFlag(true); Int2FloatOpenHashMapWritable m3 = Int2FloatOpenHashMapWritable.create(m2.serialize()); assertEquals(0, m3.size()); m1.lazyplus(m3); 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); Int2FloatOpenHashMapWritable.setLazyDecodeFlag(false); }
|
### 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:
Int2IntOpenHashMapWritable extends Int2IntOpenHashMap implements Writable { public void lazyplus(Int2IntOpenHashMapWritable m) { int[] k = m.getKeys(); int[] v = m.getValues(); for (int i = 0; i < k.length; i++) { if (this.containsKey(k[i])) { this.put(k[i], this.get(k[i]) + v[i]); } else { this.put(k[i], v[i]); } } } 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 testLazyPlus() 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); Int2IntOpenHashMapWritable.setLazyDecodeFlag(true); Int2IntOpenHashMapWritable m3 = Int2IntOpenHashMapWritable.create(m2.serialize()); assertEquals(0, m3.size()); m1.lazyplus(m3); assertEquals(3, m1.size()); assertEquals(9, m1.get(1)); assertEquals(22, m1.get(2)); assertEquals(5, m1.get(3)); Int2IntOpenHashMapWritable.setLazyDecodeFlag(false); }
|
### 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:
JsonWritable implements Writable { public byte[] serialize() throws IOException { ByteArrayOutputStream bytesOut = new ByteArrayOutputStream(); DataOutputStream dataOut = new DataOutputStream(bytesOut); write(dataOut); return bytesOut.toByteArray(); } JsonWritable(); JsonWritable(String s); void readFields(DataInput in); void write(DataOutput out); byte[] serialize(); JsonObject getJsonObject(); @Override String toString(); static JsonWritable create(DataInput in); static JsonWritable create(byte[] bytes); }### Answer:
@Test public void testSerialize() throws Exception { JsonWritable w = new JsonWritable(); JsonObject obj = w.getJsonObject(); obj.addProperty("firstName", "John"); obj.addProperty("lastName", "Smith"); JsonObject address = new JsonObject(); address.addProperty("streetAddress", "21 2nd Street"); address.addProperty("city", "New York"); address.addProperty("state", "NY"); address.addProperty("postalCode", 10021); JsonArray phoneNumbers = new JsonArray(); phoneNumbers.add(new JsonPrimitive("212 555-1234")); phoneNumbers.add(new JsonPrimitive("646 555-4567")); obj.add("address", address); obj.add("phoneNumbers", phoneNumbers); byte[] bytes = w.serialize(); JsonWritable w2 = JsonWritable.create(bytes); String s = "{\"firstName\":\"John\",\"lastName\":\"Smith\"," + "\"address\":{\"streetAddress\":\"21 2nd Street\",\"city\":\"New York\",\"state\":\"NY\",\"postalCode\":10021}," + "\"phoneNumbers\":[\"212 555-1234\",\"646 555-4567\"]}"; assertEquals(s, w2.getJsonObject().toString()); JsonObject obj2 = w2.getJsonObject(); assertEquals("John", obj2.get("firstName").getAsString()); assertEquals("Smith", obj2.get("lastName").getAsString()); assertEquals("New York", obj2.getAsJsonObject("address").get("city").getAsString()); assertEquals(2, obj2.getAsJsonArray("phoneNumbers").size()); assertEquals("212 555-1234", ((JsonPrimitive) obj2.getAsJsonArray("phoneNumbers").get(0)).getAsString()); }
|
### 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:
ArrayListWritableComparable extends ArrayList<E> implements WritableComparable<ArrayListWritableComparable<E>> { public int compareTo(ArrayListWritableComparable<E> obj) { ArrayListWritableComparable<E> that = (ArrayListWritableComparable<E>) obj; for (int i = 0; i < this.size(); i++) { if (i >= that.size()) return 1; Comparable<E> thisField = (Comparable<E>) this.get(i); Comparable<E> thatField = (Comparable<E>) that.get(i); if (thisField.equals(thatField)) { if (i == this.size() - 1) { if (this.size() > that.size()) return 1; if (this.size() < that.size()) return -1; } } else { return thisField.compareTo((E) thatField); } } return 0; } ArrayListWritableComparable(); ArrayListWritableComparable(ArrayList<E> array); void readFields(DataInput in); void write(DataOutput out); int compareTo(ArrayListWritableComparable<E> obj); String toString(); }### Answer:
@Test public void testSorting1() { ArrayListWritableComparable<Text> list1 = new ArrayListWritableComparable<Text>(); ArrayListWritableComparable<Text> list2 = new ArrayListWritableComparable<Text>(); list1.add(new Text("a")); assertTrue(list1.compareTo(list2) > 0); }
@Test public void testSorting2() { ArrayListWritableComparable<Text> list1 = new ArrayListWritableComparable<Text>(); ArrayListWritableComparable<Text> list2 = new ArrayListWritableComparable<Text>(); list1.add(new Text("a")); list2.add(new Text("b")); assertTrue(list1.compareTo(list2) < 0); assertTrue(list2.compareTo(list1) > 0); list2.clear(); list2.add(new Text("a")); assertTrue(list1.compareTo(list2) == 0); list1.add(new Text("a")); list2.add(new Text("b")); assertTrue(list1.compareTo(list2) < 0); assertTrue(list2.compareTo(list1) > 0); list1.add(new Text("a")); assertTrue(list1.compareTo(list2) < 0); }
@Test public void testSorting3() { ArrayListWritableComparable<Text> list1 = new ArrayListWritableComparable<Text>(); ArrayListWritableComparable<Text> list2 = new ArrayListWritableComparable<Text>(); ArrayListWritableComparable<Text> list3 = new ArrayListWritableComparable<Text>(); list1.add(new Text("a")); list2.add(new Text("a")); list2.add(new Text("a")); list3.add(new Text("a")); list3.add(new Text("a")); assertTrue(list2.compareTo(list3) == 0); list3.add(new Text("a")); assertTrue(list1.compareTo(list2) < 0); assertTrue(list1.compareTo(list3) < 0); assertTrue(list2.compareTo(list1) > 0); assertTrue(list2.compareTo(list3) < 0); assertTrue(list3.compareTo(list1) > 0); assertTrue(list3.compareTo(list2) > 0); }
|
### 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:
ArrayListOfLongsWritable extends ArrayListOfLongs implements
WritableComparable<ArrayListOfLongsWritable> { @Override public int compareTo(ArrayListOfLongsWritable obj) { ArrayListOfLongsWritable other = (ArrayListOfLongsWritable) obj; if (isEmpty()) { if (other.isEmpty()) { return 0; } else { return -1; } } for (int i = 0; i < size(); i++) { if (other.size() <= i) { return 1; } if (get(i) < other.get(i)) { return -1; } else if (get(i) > other.get(i)) { return 1; } } if (other.size() > size()) { return -1; } else { return 0; } } 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 testCompare() { ArrayListOfLongsWritable a = new ArrayListOfLongsWritable(); a.add(one).add(three).add(five); ArrayListOfLongsWritable b = new ArrayListOfLongsWritable(); b.add(one).add(three).add(five).add(seven); assertTrue(b.compareTo(a) > 0); b.remove(3); assertTrue(b.compareTo(a) == 0); b.remove(2); assertTrue(b.compareTo(a) < 0); ArrayListOfLongsWritable c = new ArrayListOfLongsWritable(); assertTrue(b.compareTo(c) > 0); assertTrue(c.compareTo(a) < 0); assertTrue(a.compareTo(c) > 0); assertTrue(c.compareTo(b) < 0); }
@Test public void testCompare2() { ArrayListOfLongsWritable a = new ArrayListOfLongsWritable(); a.add(one).add(three).add(six); ArrayListOfLongsWritable b = new ArrayListOfLongsWritable(); b.add(one).add(three).add(four); assertTrue(a.compareTo(b) > 0); ArrayListOfLongsWritable c = new ArrayListOfLongsWritable(); c.add(one).add(three).add(four).add(nine); assertTrue(c.compareTo(a) < 0); assertTrue(b.compareTo(c) < 0); ArrayListOfLongsWritable d = new ArrayListOfLongsWritable(); d.add(two).add(four); ArrayListOfLongsWritable e = new ArrayListOfLongsWritable(); e.add(zero).add(two); assertTrue(d.compareTo(a) > 0); assertTrue(d.compareTo(b) > 0); assertTrue(d.compareTo(c) > 0); assertTrue(e.compareTo(a) < 0); assertTrue(e.compareTo(b) < 0); assertTrue(e.compareTo(c) < 0); assertTrue(e.compareTo(d) < 0); }
|
### 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 float remove(int index) { if (index >= size) { throw new ArrayIndexOutOfBoundsException(); } float oldValue = array[index]; int numMoved = size - index - 1; if (numMoved > 0) { System.arraycopy(array, index + 1, array, index, numMoved); } size--; return oldValue; } 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 testArrayConstructor() { float[] arr = new float[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; assertEquals(5, arr.length); ArrayListOfFloats list = new ArrayListOfFloats(arr); list.remove(2); assertEquals(1.0f, arr[0], 10e-6); assertEquals(2.0f, arr[1], 10e-6); assertEquals(3.0f, arr[2], 10e-6); assertEquals(4.0f, arr[3], 10e-6); assertEquals(5.0f, arr[4], 10e-6); }
@Test public void testRemove() { ArrayListOfFloats list = new ArrayListOfFloats(); for (int i = 0; i < 10; i++) { list.add((float) i); } list.remove(list.indexOf(5.0f)); assertEquals(9, list.size()); assertEquals(0.0f, list.get(0), 10e-6); assertEquals(1.0f, list.get(1), 10e-6); assertEquals(2.0f, list.get(2), 10e-6); assertEquals(3.0f, list.get(3), 10e-6); assertEquals(4.0f, list.get(4), 10e-6); assertEquals(6.0f, list.get(5), 10e-6); assertEquals(7.0f, list.get(6), 10e-6); assertEquals(8.0f, list.get(7), 10e-6); assertEquals(9.0f, list.get(8), 10e-6); list.remove(list.indexOf((short) 9)); assertEquals(8, list.size); assertEquals(0.0f, list.get(0), 10e-6); assertEquals(1.0f, list.get(1), 10e-6); assertEquals(2.0f, list.get(2), 10e-6); assertEquals(3.0f, list.get(3), 10e-6); assertEquals(4.0f, list.get(4), 10e-6); assertEquals(6.0f, list.get(5), 10e-6); assertEquals(7.0f, list.get(6), 10e-6); assertEquals(8.0f, list.get(7), 10e-6); }
|
### Question:
ArrayListOfFloats implements RandomAccess, Cloneable, Iterable<Float> { public ArrayListOfFloats clone() { return new ArrayListOfFloats(Arrays.copyOf(array, this.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 testClone() { int size = 100000; Random r = new Random(); float[] floats = new float[size]; ArrayListOfFloats list1 = new ArrayListOfFloats(); for (int i = 0; i < size; i++) { float k = r.nextFloat(); list1.add(k); floats[i] = k; } ArrayListOfFloats list2 = list1.clone(); assertEquals(size, list1.size()); assertEquals(size, list2.size()); for (int i = 0; i < size; i++) { list2.set(i, floats[i] + 1); } assertEquals(size, list1.size()); for (int i = 0; i < size; i++) { assertEquals(floats[i], list1.get(i), 10e-5); } assertEquals(size, list1.size()); for (int i = 0; i < size; i++) { assertEquals(floats[i] + 1, list2.get(i), 10e-5); } }
|
### Question:
ArrayListOfFloats implements RandomAccess, Cloneable, Iterable<Float> { public String toString(int n) { StringBuilder s = new StringBuilder(); s.append("["); int sz = size() > n ? n : size; for (int i = 0; i < sz; i++) { s.append(get(i)); if (i < sz - 1) { s.append(", "); } } s.append(size() > n ? String.format(" ... (%d more) ]", size() - n) : "]"); return s.toString(); } 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 testToString() { int size = 10; Random r = new Random(); ArrayListOfFloats list = new ArrayListOfFloats(); for (int i = 0; i < size; i++) { list.add(r.nextFloat()); } String out = list.toString(); for (int i = 0; i < size; i++) { float v = list.get(i); assertTrue(out.indexOf(new Float(v).toString()) != -1); } for (int i = 0; i < size; i++) { list.add(r.nextFloat()); } out = list.toString(); for (int i = size; i < size + size; i++) { float v = list.get(i); assertTrue(out.indexOf(new Float(v).toString()) == -1); } assertTrue(out.indexOf(size + " more") != -1); }
|
### 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 ArrayListOfFloats subList(int start, int end) { ArrayListOfFloats sublst = new ArrayListOfFloats(end - start + 1); for (int i = start; i <= end; i++) { sublst.add(get(i)); } return sublst; } 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 testSubList() { ArrayListOfFloats a = new ArrayListOfFloats(new float[] { 1, 2, 3, 4, 5, 6, 7 }); ArrayListOfFloats c = a.subList(1, 5); assertEquals(5, c.size()); assertTrue(Math.abs(2 - c.get(0)) < 0.0001); assertTrue(Math.abs(3 - c.get(1)) < 0.0001); assertTrue(Math.abs(4 - c.get(2)) < 0.0001); assertTrue(Math.abs(5 - c.get(3)) < 0.0001); assertTrue(Math.abs(6 - c.get(4)) < 0.0001); a.clear(); assertEquals(5, c.size()); assertTrue(Math.abs(2 - c.get(0)) < 0.0001); assertTrue(Math.abs(3 - c.get(1)) < 0.0001); assertTrue(Math.abs(4 - c.get(2)) < 0.0001); assertTrue(Math.abs(5 - c.get(3)) < 0.0001); assertTrue(Math.abs(6 - c.get(4)) < 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:
Int2IntOpenHashMapWritable extends Int2IntOpenHashMap implements Writable { public Int2IntMap.Entry[] getEntriesSortedByValue() { if (this.size() == 0) return null; Int2IntMap.Entry[] entries = new Int2IntMap.Entry[this.size()]; entries = this.int2IntEntrySet().toArray(entries); Arrays.sort(entries, new Comparator<Int2IntMap.Entry>() { public int compare(Int2IntMap.Entry e1, Int2IntMap.Entry e2) { if (e1.getIntValue() > e2.getIntValue()) { return -1; } else if (e1.getIntValue() < e2.getIntValue()) { return 1; } if (e1.getIntKey() == e2.getIntKey()) return 0; return e1.getIntKey() > e2.getIntKey() ? 1 : -1; } }); return entries; } 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 testSortedEntries1() { Int2IntOpenHashMapWritable m = new Int2IntOpenHashMapWritable(); m.put(1, 5); m.put(2, 2); m.put(3, 3); m.put(4, 3); m.put(5, 1); Int2IntMap.Entry[] e = m.getEntriesSortedByValue(); assertEquals(5, e.length); assertEquals(1, e[0].getIntKey()); assertEquals(5, e[0].getIntValue()); assertEquals(3, e[1].getIntKey()); assertEquals(3, e[1].getIntValue()); assertEquals(4, e[2].getIntKey()); assertEquals(3, e[2].getIntValue()); assertEquals(2, e[3].getIntKey()); assertEquals(2, e[3].getIntValue()); assertEquals(5, e[4].getIntKey()); assertEquals(1, e[4].getIntValue()); }
@Test public void testSortedEntries2() { Int2IntOpenHashMapWritable m = new Int2IntOpenHashMapWritable(); m.put(1, 5); m.put(2, 2); m.put(3, 3); m.put(4, 3); m.put(5, 1); Int2IntMap.Entry[] e = m.getEntriesSortedByValue(2); assertEquals(2, e.length); assertEquals(1, e[0].getIntKey()); assertEquals(5, e[0].getIntValue()); assertEquals(3, e[1].getIntKey()); assertEquals(3, e[1].getIntValue()); }
@Test public void testSortedEntries3() { Int2IntOpenHashMapWritable m = new Int2IntOpenHashMapWritable(); m.put(1, 5); m.put(2, 2); Int2IntMap.Entry[] e = m.getEntriesSortedByValue(5); assertEquals(2, e.length); assertEquals(1, e[0].getIntKey()); assertEquals(5, e[0].getIntValue()); assertEquals(2, e[1].getIntKey()); assertEquals(2, e[1].getIntValue()); }
@Test public void testSortedEntries4() { Int2IntOpenHashMapWritable m = new Int2IntOpenHashMapWritable(); Int2IntMap.Entry[] e = m.getEntriesSortedByValue(); assertTrue(e == null); }
|
### 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:
ArrayListOfIntsWritable extends ArrayListOfInts implements
WritableComparable<ArrayListOfIntsWritable> { @Override public int compareTo(ArrayListOfIntsWritable obj) { ArrayListOfIntsWritable other = (ArrayListOfIntsWritable) obj; if (isEmpty()) { if (other.isEmpty()) { return 0; } else { return -1; } } for (int i = 0; i < size(); i++) { if (other.size() <= i) { return 1; } if (get(i) < other.get(i)) { return -1; } else if (get(i) > other.get(i)) { return 1; } } if (other.size() > size()) { return -1; } else { return 0; } } 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 testCompare() { ArrayListOfIntsWritable a = new ArrayListOfIntsWritable(); a.add(one).add(three).add(five); ArrayListOfIntsWritable b = new ArrayListOfIntsWritable(); b.add(one).add(three).add(five).add(seven); assertTrue(b.compareTo(a) > 0); b.remove(3); assertTrue(b.compareTo(a) == 0); b.remove(2); assertTrue(b.compareTo(a) < 0); ArrayListOfIntsWritable c = new ArrayListOfIntsWritable(); assertTrue(b.compareTo(c) > 0); assertTrue(c.compareTo(a) < 0); assertTrue(a.compareTo(c) > 0); assertTrue(c.compareTo(b) < 0); }
@Test public void testCompare2() { ArrayListOfIntsWritable a = new ArrayListOfIntsWritable(); a.add(one).add(three).add(six); ArrayListOfIntsWritable b = new ArrayListOfIntsWritable(); b.add(one).add(three).add(four); assertTrue(a.compareTo(b) > 0); ArrayListOfIntsWritable c = new ArrayListOfIntsWritable(); c.add(one).add(three).add(four).add(nine); assertTrue(c.compareTo(a) < 0); assertTrue(b.compareTo(c) < 0); ArrayListOfIntsWritable d = new ArrayListOfIntsWritable(); d.add(two).add(four); ArrayListOfIntsWritable e = new ArrayListOfIntsWritable(); e.add(zero).add(two); assertTrue(d.compareTo(a) > 0); assertTrue(d.compareTo(b) > 0); assertTrue(d.compareTo(c) > 0); assertTrue(e.compareTo(a) < 0); assertTrue(e.compareTo(b) < 0); assertTrue(e.compareTo(c) < 0); assertTrue(e.compareTo(d) < 0); }
|
### Question:
ArrayListOfDoublesWritable extends ArrayListOfDoubles implements
WritableComparable<ArrayListOfDoublesWritable> { @Override public int compareTo(ArrayListOfDoublesWritable obj) { ArrayListOfDoublesWritable other = (ArrayListOfDoublesWritable) obj; if (isEmpty()) { if (other.isEmpty()) { return 0; } else { return -1; } } for (int i = 0; i < size(); i++) { if (other.size() <= i) { return 1; } if (get(i) < other.get(i)) { return -1; } else if (get(i) > other.get(i)) { return 1; } } if (other.size() > size()) { return -1; } else { return 0; } } ArrayListOfDoublesWritable(); ArrayListOfDoublesWritable(int initialCapacity); ArrayListOfDoublesWritable(ArrayListOfDoublesWritable other); ArrayListOfDoublesWritable(double[] arr); void readFields(DataInput in); void write(DataOutput out); @Override String toString(); static ArrayListOfDoublesWritable fromArrayListOfDoubles(ArrayListOfDoubles arr); @Override int compareTo(ArrayListOfDoublesWritable obj); }### Answer:
@Test public void testCompare() { ArrayListOfDoublesWritable a = new ArrayListOfDoublesWritable(); a.add(one).add(three).add(five); ArrayListOfDoublesWritable b = new ArrayListOfDoublesWritable(); b.add(one).add(three).add(five).add(seven); assertTrue(b.compareTo(a) > 0); b.remove(3); assertTrue(b.compareTo(a) == 0); b.remove(2); assertTrue(b.compareTo(a) < 0); ArrayListOfDoublesWritable c = new ArrayListOfDoublesWritable(); assertTrue(b.compareTo(c) > 0); assertTrue(c.compareTo(a) < 0); assertTrue(a.compareTo(c) > 0); assertTrue(c.compareTo(b) < 0); }
@Test public void testCompare2() { ArrayListOfDoublesWritable a = new ArrayListOfDoublesWritable(); a.add(one).add(three).add(six); ArrayListOfDoublesWritable b = new ArrayListOfDoublesWritable(); b.add(one).add(three).add(four); assertTrue(a.compareTo(b) > 0); ArrayListOfDoublesWritable c = new ArrayListOfDoublesWritable(); c.add(one).add(three).add(four).add(nine); assertTrue(c.compareTo(a) < 0); assertTrue(b.compareTo(c) < 0); ArrayListOfDoublesWritable d = new ArrayListOfDoublesWritable(); d.add(two).add(four); ArrayListOfDoublesWritable e = new ArrayListOfDoublesWritable(); e.add(zero).add(two); assertTrue(d.compareTo(a) > 0); assertTrue(d.compareTo(b) > 0); assertTrue(d.compareTo(c) > 0); assertTrue(e.compareTo(a) < 0); assertTrue(e.compareTo(b) < 0); assertTrue(e.compareTo(c) < 0); assertTrue(e.compareTo(d) < 0); }
|
### 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 int remove(int index) { if (index >= size) { throw new ArrayIndexOutOfBoundsException(); } int oldValue = array[index]; int numMoved = size - index - 1; if (numMoved > 0) { System.arraycopy(array, index + 1, array, index, numMoved); } size--; return oldValue; } 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 testArrayConstructor() { int[] arr = new int[] { 1, 2, 3, 4, 5 }; assertEquals(5, arr.length); ArrayListOfInts list = new ArrayListOfInts(arr); list.remove(2); assertEquals(1, arr[0]); assertEquals(2, arr[1]); assertEquals(3, arr[2]); assertEquals(4, arr[3]); assertEquals(5, arr[4]); }
@Test public void testRemove() { ArrayListOfInts list = new ArrayListOfInts(); for (int i = 0; i < 10; i++) { list.add(i); } list.remove(list.indexOf(5)); assertEquals(9, list.size()); assertEquals(0, list.get(0)); assertEquals(1, list.get(1)); assertEquals(2, list.get(2)); assertEquals(3, list.get(3)); assertEquals(4, list.get(4)); assertEquals(6, list.get(5)); assertEquals(7, list.get(6)); assertEquals(8, list.get(7)); assertEquals(9, list.get(8)); list.remove(list.indexOf(9)); assertEquals(8, list.size()); assertEquals(0, list.get(0)); assertEquals(1, list.get(1)); assertEquals(2, list.get(2)); assertEquals(3, list.get(3)); assertEquals(4, list.get(4)); assertEquals(6, list.get(5)); assertEquals(7, list.get(6)); assertEquals(8, list.get(7)); }
|
### Question:
ArrayListOfInts implements RandomAccess, Cloneable, Iterable<Integer> { public ArrayListOfInts clone() { return new ArrayListOfInts(Arrays.copyOf(array, this.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 testClone() { int size = 100000; Random r = new Random(); int[] ints = new int[size]; ArrayListOfInts list1 = new ArrayListOfInts(); for (int i = 0; i < size; i++) { int k = r.nextInt(size); list1.add(k); ints[i] = k; } ArrayListOfInts list2 = list1.clone(); assertEquals(size, list1.size()); assertEquals(size, list2.size()); for (int i = 0; i < size; i++) { list2.set(i, ints[i] + 1); } assertEquals(size, list1.size()); for (int i = 0; i < size; i++) { assertEquals(ints[i], list1.get(i)); } assertEquals(size, list1.size()); for (int i = 0; i < size; i++) { assertEquals(ints[i] + 1, list2.get(i)); } }
|
### Question:
ArrayListOfInts implements RandomAccess, Cloneable, Iterable<Integer> { public String toString(int n) { StringBuilder s = new StringBuilder(); s.append("["); int sz = size() > n ? n : size; for (int i = 0; i < sz; i++) { s.append(get(i)); if (i < sz - 1) { s.append(", "); } } s.append(size() > n ? String.format(" ... (%d more) ]", size() - n) : "]"); return s.toString(); } 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 testToString1() { assertEquals("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", new ArrayListOfInts(1, 11).toString()); assertEquals("[1, 2, 3, 4, 5 ... (5 more) ]", new ArrayListOfInts(1, 11).toString(5)); assertEquals("[1, 2, 3, 4, 5]", new ArrayListOfInts(1, 6).toString()); assertEquals("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]", new ArrayListOfInts(1, 12).toString(11)); assertEquals("[]", new ArrayListOfInts().toString()); }
|
### 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)); }
|
### Question:
ArrayListOfInts implements RandomAccess, Cloneable, Iterable<Integer> { public ArrayListOfInts subList(int start, int end) { ArrayListOfInts sublst = new ArrayListOfInts(end - start + 1); for (int i = start; i <= end; i++) { sublst.add(get(i)); } return sublst; } 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 testSubList() { ArrayListOfInts a = new ArrayListOfInts(new int[] { 1, 2, 3, 4, 5, 6, 7 }); ArrayListOfInts b = a.subList(1, 5); assertEquals(5, b.size()); assertEquals(2, b.get(0)); assertEquals(3, b.get(1)); assertEquals(4, b.get(2)); assertEquals(5, b.get(3)); assertEquals(6, b.get(4)); a.clear(); assertEquals(5, b.size()); assertEquals(2, b.get(0)); assertEquals(3, b.get(1)); assertEquals(4, b.get(2)); assertEquals(5, b.get(3)); assertEquals(6, b.get(4)); }
|
### Question:
ArrayListOfInts implements RandomAccess, Cloneable, Iterable<Integer> { public void addUnique(int[] arr) { for (int i = 0; i < arr.length; i++) { int elt = arr[i]; if (!contains(elt)) { add(elt); } } } 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 testAddUnique() { ArrayListOfInts a = new ArrayListOfInts(new int[] { 1, 2, 3, 4, 5, 6, 7 }); a.addUnique(new int[] { 8, 0, 2, 5, -1, 11, 9 }); assertEquals(12, a.size()); assertEquals(0, a.get(8)); assertEquals(-1, a.get(9)); assertEquals(11, a.get(10)); assertEquals(9, a.get(11)); }
|
### Question:
ArrayListOfDoubles implements RandomAccess, Cloneable, Iterable<Double> { public int size() { return size; } ArrayListOfDoubles(int initialCapacity); ArrayListOfDoubles(); ArrayListOfDoubles(double[] a); ArrayListOfDoubles(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(double n); int indexOf(double n); int lastIndexOf(double n); ArrayListOfDoubles clone(); double get(int index); double set(int index, double element); ArrayListOfDoubles add(double e); ArrayListOfDoubles add(int index, double element); double remove(int index); void clear(); double[] getArray(); Iterator<Double> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfDoubles intersection(ArrayListOfDoubles other); ArrayListOfDoubles merge(ArrayListOfDoubles sortedLst); ArrayListOfDoubles subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testInitialSize() { ArrayListOfDoubles a = new ArrayListOfDoubles(); assertEquals(0, a.size()); }
|
### Question:
ArrayListOfDoubles implements RandomAccess, Cloneable, Iterable<Double> { public double remove(int index) { if (index >= size) { throw new ArrayIndexOutOfBoundsException(); } double oldValue = array[index]; int numMoved = size - index - 1; if (numMoved > 0) { System.arraycopy(array, index + 1, array, index, numMoved); } size--; return oldValue; } ArrayListOfDoubles(int initialCapacity); ArrayListOfDoubles(); ArrayListOfDoubles(double[] a); ArrayListOfDoubles(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(double n); int indexOf(double n); int lastIndexOf(double n); ArrayListOfDoubles clone(); double get(int index); double set(int index, double element); ArrayListOfDoubles add(double e); ArrayListOfDoubles add(int index, double element); double remove(int index); void clear(); double[] getArray(); Iterator<Double> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfDoubles intersection(ArrayListOfDoubles other); ArrayListOfDoubles merge(ArrayListOfDoubles sortedLst); ArrayListOfDoubles subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testArrayConstructor() { double[] arr = new double[] { 1.0, 2.0, 3.0, 4.0, 5.0 }; assertEquals(5, arr.length); ArrayListOfDoubles list = new ArrayListOfDoubles(arr); list.remove(2); assertEquals(1.0, arr[0], 10e-6); assertEquals(2.0, arr[1], 10e-6); assertEquals(3.0, arr[2], 10e-6); assertEquals(4.0, arr[3], 10e-6); assertEquals(5.0, arr[4], 10e-6); }
@Test public void testRemove() { ArrayListOfDoubles list = new ArrayListOfDoubles(); for (int i = 0; i < 10; i++) { list.add((double) i); } list.remove(list.indexOf(5.0)); assertEquals(9, list.size()); assertEquals(0.0, list.get(0), 10e-6); assertEquals(1.0, list.get(1), 10e-6); assertEquals(2.0, list.get(2), 10e-6); assertEquals(3.0, list.get(3), 10e-6); assertEquals(4.0, list.get(4), 10e-6); assertEquals(6.0, list.get(5), 10e-6); assertEquals(7.0, list.get(6), 10e-6); assertEquals(8.0, list.get(7), 10e-6); assertEquals(9.0, list.get(8), 10e-6); list.remove(list.indexOf((short) 9)); assertEquals(8, list.size); assertEquals(0.0, list.get(0), 10e-6); assertEquals(1.0, list.get(1), 10e-6); assertEquals(2.0, list.get(2), 10e-6); assertEquals(3.0, list.get(3), 10e-6); assertEquals(4.0, list.get(4), 10e-6); assertEquals(6.0, list.get(5), 10e-6); assertEquals(7.0, list.get(6), 10e-6); assertEquals(8.0, list.get(7), 10e-6); }
|
### Question:
ArrayListOfDoubles implements RandomAccess, Cloneable, Iterable<Double> { public ArrayListOfDoubles clone() { return new ArrayListOfDoubles(Arrays.copyOf(array, this.size())); } ArrayListOfDoubles(int initialCapacity); ArrayListOfDoubles(); ArrayListOfDoubles(double[] a); ArrayListOfDoubles(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(double n); int indexOf(double n); int lastIndexOf(double n); ArrayListOfDoubles clone(); double get(int index); double set(int index, double element); ArrayListOfDoubles add(double e); ArrayListOfDoubles add(int index, double element); double remove(int index); void clear(); double[] getArray(); Iterator<Double> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfDoubles intersection(ArrayListOfDoubles other); ArrayListOfDoubles merge(ArrayListOfDoubles sortedLst); ArrayListOfDoubles subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testClone() { int size = 100000; Random r = new Random(); double[] doubles = new double[size]; ArrayListOfDoubles list1 = new ArrayListOfDoubles(); for (int i = 0; i < size; i++) { double k = r.nextDouble(); list1.add(k); doubles[i] = k; } ArrayListOfDoubles list2 = list1.clone(); assertEquals(size, list1.size()); assertEquals(size, list2.size()); for (int i = 0; i < size; i++) { list2.set(i, doubles[i] + 1); } assertEquals(size, list1.size()); for (int i = 0; i < size; i++) { assertEquals(doubles[i], list1.get(i), 10e-5); } assertEquals(size, list1.size()); for (int i = 0; i < size; i++) { assertEquals(doubles[i] + 1, list2.get(i), 10e-5); } }
|
### Question:
ArrayListOfDoubles implements RandomAccess, Cloneable, Iterable<Double> { public String toString(int n) { StringBuilder s = new StringBuilder(); s.append("["); int sz = size() > n ? n : size; for (int i = 0; i < sz; i++) { s.append(get(i)); if (i < sz - 1) { s.append(", "); } } s.append(size() > n ? String.format(" ... (%d more) ]", size() - n) : "]"); return s.toString(); } ArrayListOfDoubles(int initialCapacity); ArrayListOfDoubles(); ArrayListOfDoubles(double[] a); ArrayListOfDoubles(int first, int last); void trimToSize(); void ensureCapacity(int minCapacity); int size(); void setSize(int sz); boolean isEmpty(); boolean contains(double n); int indexOf(double n); int lastIndexOf(double n); ArrayListOfDoubles clone(); double get(int index); double set(int index, double element); ArrayListOfDoubles add(double e); ArrayListOfDoubles add(int index, double element); double remove(int index); void clear(); double[] getArray(); Iterator<Double> iterator(); String toString(int n); @Override String toString(); void sort(); ArrayListOfDoubles intersection(ArrayListOfDoubles other); ArrayListOfDoubles merge(ArrayListOfDoubles sortedLst); ArrayListOfDoubles subList(int start, int end); void addUnique(int[] arr); void shiftLastNToTop(int n); @Override boolean equals(Object obj); }### Answer:
@Test public void testToString() { int size = 10; Random r = new Random(); ArrayListOfDoubles list = new ArrayListOfDoubles(); for (int i = 0; i < size; i++) { list.add(r.nextDouble()); } String out = list.toString(); for (int i = 0; i < size; i++) { double v = list.get(i); assertTrue(out.indexOf(new Double(v).toString()) != -1); } for (int i = 0; i < size; i++) { list.add(r.nextFloat()); } out = list.toString(); for (int i = size; i < size + size; i++) { double v = list.get(i); assertTrue(out.indexOf(new Double(v).toString()) == -1); } assertTrue(out.indexOf(size + " more") != -1); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.