org.apache.logging.log4j.util.SortedArrayStringMap.size java code examples

@Override
public boolean equals(final Object obj) {
  if (obj == this) {
    return true;
  }
  if (!(obj instanceof SortedArrayStringMap)) {
    return false;
  }
  final SortedArrayStringMap other = (SortedArrayStringMap) obj;
  if (this.size() != other.size()) {
    return false;
  }
  for (int i = 0; i < size(); i++) {
    if (!Objects.equals(keys[i], other.keys[i])) {
      return false;
    }
    if (!Objects.equals(values[i], other.values[i])) {
      return false;
    }
  }
  return true;
}

@Override
public Map<String, String> toMap() {
  final Map<String, String> result = new HashMap<>(size());
  for (int i = 0; i < size(); i++) {
    final Object value = getValueAt(i);
    result.put(getKeyAt(i), value == null ? null : String.valueOf(value));
  }
  return result;
}

public void testConstructorAllowsZeroCapacity() throws Exception {
  SortedArrayStringMap sortedArrayStringMap = new SortedArrayStringMap(0);
  assertEquals(0, sortedArrayStringMap.size());
}

@Test
public void testConstructorIgnoresNull() throws Exception {
  assertEquals(0, new SortedArrayStringMap((SortedArrayStringMap) null).size());
}

@Test
public void testSizeAndIsEmpty() throws Exception {
  final SortedArrayStringMap original = new SortedArrayStringMap();
  assertEquals(0, original.size());
  assertTrue("initial", original.isEmpty());
  original.putValue("a", "avalue");
  assertEquals(1, original.size());
  assertFalse("size=" + original.size(), original.isEmpty());
  original.putValue("B", "Bvalue");
  assertEquals(2, original.size());
  assertFalse("size=" + original.size(), original.isEmpty());
  original.putValue("3", "3value");
  assertEquals(3, original.size());
  assertFalse("size=" + original.size(), original.isEmpty());
  original.remove("B");
  assertEquals(2, original.size());
  assertFalse("size=" + original.size(), original.isEmpty());
  original.remove("3");
  assertEquals(1, original.size());
  assertFalse("size=" + original.size(), original.isEmpty());
  original.remove("a");
  assertEquals(0, original.size());
  assertTrue("size=" + original.size(), original.isEmpty());
}

@Test
public void testClear() throws Exception {
  final SortedArrayStringMap original = new SortedArrayStringMap();
  original.putValue("a", "avalue");
  original.putValue("B", "Bvalue");
  original.putValue("3", "3value");
  assertEquals(3, original.size());
  original.clear();
  assertEquals(0, original.size());
  // ensure slots in the values array are nulled out
  final Field f = SortedArrayStringMap.class.getDeclaredField("values");
  f.setAccessible(true);
  final Object[] values = (Object[]) f.get(original);
  for (int i = 0; i < values.length; i++) {
    assertNull(values[i]);
  }
}

@Test
public void testRemove() {
  final SortedArrayStringMap original = new SortedArrayStringMap();
  original.putValue("a", "avalue");
  assertEquals(1, original.size());
  assertEquals("avalue", original.getValue("a"));
  original.remove("a");
  assertEquals(0, original.size());
  assertNull("no a val", original.getValue("a"));
  original.remove("B");
  assertEquals(0, original.size());
  assertNull("no B val", original.getValue("B"));
}

  @Override
  public void accept(final String key, final String value) {
    assertEquals("key", key, original.getKeyAt(count));
    assertEquals("val", value, original.getValueAt(count));
    count++;
    assertTrue("count should not exceed size but was " + count, count <= original.size());
  }
});

@Test
public void testNullValuesArePreserved() {
  final SortedArrayStringMap original = new SortedArrayStringMap();
  original.putValue("a", "avalue");
  assertEquals(1, original.size());
  assertEquals("avalue", original.getValue("a"));
  original.putValue("a", null);
  assertEquals(1, original.size());
  assertNull("no a val", original.getValue("a"));
  original.putValue("B", null);
  assertEquals(2, original.size());
  assertNull("no B val", original.getValue("B"));
}

  @Override
  public void accept(final String key, final String value, final State state) {
    assertEquals("key", key, state.data.getKeyAt(state.count));
    assertEquals("val", value, state.data.getValueAt(state.count));
    state.count++;
    assertTrue("count should not exceed size but was " + state.count,
        state.count <= state.data.size());
  }
};

@Test
public void testNullKeysAllowed() {
  final SortedArrayStringMap original = new SortedArrayStringMap();
  original.putValue("a", "avalue");
  original.putValue("B", "Bvalue");
  original.putValue("3", "3value");
  original.putValue("c", "cvalue");
  original.putValue("d", "dvalue");
  assertEquals(5, original.size());
  assertEquals("{3=3value, B=Bvalue, a=avalue, c=cvalue, d=dvalue}", original.toString());
  original.putValue(null, "nullvalue");
  assertEquals(6, original.size());
  assertEquals("{null=nullvalue, 3=3value, B=Bvalue, a=avalue, c=cvalue, d=dvalue}", original.toString());
  original.putValue(null, "otherNullvalue");
  assertEquals("{null=otherNullvalue, 3=3value, B=Bvalue, a=avalue, c=cvalue, d=dvalue}", original.toString());
  assertEquals(6, original.size());
  original.putValue(null, "nullvalue");
  assertEquals(6, original.size());
  assertEquals("{null=nullvalue, 3=3value, B=Bvalue, a=avalue, c=cvalue, d=dvalue}", original.toString());
  original.putValue(null, "abc");
  assertEquals(6, original.size());
  assertEquals("{null=abc, 3=3value, B=Bvalue, a=avalue, c=cvalue, d=dvalue}", original.toString());
}

@Test
public void testPutAllSelfDoesNotModify() {
  final SortedArrayStringMap original = new SortedArrayStringMap();
  original.putValue("a", "aaa");
  original.putValue("b", "bbb");
  original.putValue("c", "ccc");
  assertEquals("size", 3, original.size());
  // putAll with self
  original.putAll(original);
  assertEquals("size after put empty", 3, original.size());
  assertEquals("aaa", original.getValue("a"));
  assertEquals("bbb", original.getValue("b"));
  assertEquals("ccc", original.getValue("c"));
}

  @Test
  public void testForEachTriConsumer() throws Exception {
    final SortedArrayStringMap original = new SortedArrayStringMap();
    original.putValue("a", "avalue");
    original.putValue("B", "Bvalue");
    original.putValue("3", "3value");

    final State state = new State();
    state.data = original;
    original.forEach(COUNTER, state);
    assertEquals(state.count, original.size());
  }
}

@Test
public void testPutAll_overwritesSameKeys1() throws Exception {
  final SortedArrayStringMap original = new SortedArrayStringMap();
  original.putValue("a", "aORIG");
  original.putValue("b", "bORIG");
  original.putValue("c", "cORIG");
  final SortedArrayStringMap other = new SortedArrayStringMap();
  other.putValue("1", "11");
  other.putValue("2", "22");
  other.putValue("a", "aa");
  other.putValue("c", "cc");
  original.putAll(other);
  assertEquals("size after put other", 5, original.size());
  assertEquals("aa", original.getValue("a"));
  assertEquals("bORIG", original.getValue("b"));
  assertEquals("cc", original.getValue("c"));
  assertEquals("11", original.getValue("1"));
  assertEquals("22", original.getValue("2"));
}

@Test
public void testPutAll_nullKeyInSmallOriginal() throws Exception {
  final SortedArrayStringMap original = new SortedArrayStringMap();
  original.putValue(null, "nullORIG");
  original.putValue("a", "aORIG");
  original.putValue("b", "bORIG");
  final SortedArrayStringMap other = new SortedArrayStringMap();
  other.putValue("1", "11");
  other.putValue("2", "22");
  other.putValue("3", "33");
  other.putValue("a", "aa");
  original.putAll(other);
  assertEquals("size after put other", 6, original.size());
  assertEquals("aa", original.getValue("a"));
  assertEquals("bORIG", original.getValue("b"));
  assertEquals("11", original.getValue("1"));
  assertEquals("22", original.getValue("2"));
  assertEquals("33", original.getValue("3"));
  assertEquals("nullORIG", original.getValue(null));
}

@Test
public void testPutAll_nullKeyInLargeAdditional() throws Exception {
  final SortedArrayStringMap original = new SortedArrayStringMap();
  original.putValue("a", "aORIG");
  original.putValue("b", "bORIG");
  final SortedArrayStringMap other = new SortedArrayStringMap();
  other.putValue(null, "nullNEW");
  other.putValue("1", "11");
  other.putValue("2", "22");
  other.putValue("3", "33");
  other.putValue("a", "aa");
  original.putAll(other);
  assertEquals("size after put other", 6, original.size());
  assertEquals("aa", original.getValue("a"));
  assertEquals("bORIG", original.getValue("b"));
  assertEquals("11", original.getValue("1"));
  assertEquals("22", original.getValue("2"));
  assertEquals("33", original.getValue("3"));
  assertEquals("nullNEW", original.getValue(null));
}

@Test
public void testPutAll_nullKeyInBoth_SmallOriginal() throws Exception {
  final SortedArrayStringMap original = new SortedArrayStringMap();
  original.putValue(null, "nullORIG");
  original.putValue("a", "aORIG");
  original.putValue("b", "bORIG");
  final SortedArrayStringMap other = new SortedArrayStringMap();
  other.putValue(null, "nullNEW");
  other.putValue("1", "11");
  other.putValue("2", "22");
  other.putValue("3", "33");
  other.putValue("a", "aa");
  original.putAll(other);
  assertEquals("size after put other", 6, original.size());
  assertEquals("aa", original.getValue("a"));
  assertEquals("bORIG", original.getValue("b"));
  assertEquals("11", original.getValue("1"));
  assertEquals("22", original.getValue("2"));
  assertEquals("33", original.getValue("3"));
  assertEquals("nullNEW", original.getValue(null));
}

@Test
public void testPutAll_overwritesSameKeys2() throws Exception {
  final SortedArrayStringMap original = new SortedArrayStringMap();
  original.putValue("a", "aORIG");
  original.putValue("b", "bORIG");
  original.putValue("c", "cORIG");
  original.putValue("d", "dORIG");
  original.putValue("e", "eORIG");
  final SortedArrayStringMap other = new SortedArrayStringMap();
  other.putValue("1", "11");
  other.putValue("2", "22");
  other.putValue("a", "aa");
  other.putValue("c", "cc");
  original.putAll(other);
  assertEquals("size after put other", 7, original.size());
  assertEquals("aa", original.getValue("a"));
  assertEquals("bORIG", original.getValue("b"));
  assertEquals("cc", original.getValue("c"));
  assertEquals("dORIG", original.getValue("d"));
  assertEquals("eORIG", original.getValue("e"));
  assertEquals("11", original.getValue("1"));
  assertEquals("22", original.getValue("2"));
}

@Test
public void testPutAll_nullKeyInLargeOriginal() throws Exception {
  final SortedArrayStringMap original = new SortedArrayStringMap();
  original.putValue(null, "nullORIG");
  original.putValue("a", "aORIG");
  original.putValue("b", "bORIG");
  original.putValue("c", "cORIG");
  original.putValue("d", "dORIG");
  original.putValue("e", "eORIG");
  final SortedArrayStringMap other = new SortedArrayStringMap();
  other.putValue("1", "11");
  other.putValue("a", "aa");
  original.putAll(other);
  assertEquals("size after put other", 7, original.size());
  assertEquals("aa", original.getValue("a"));
  assertEquals("bORIG", original.getValue("b"));
  assertEquals("cORIG", original.getValue("c"));
  assertEquals("dORIG", original.getValue("d"));
  assertEquals("eORIG", original.getValue("e"));
  assertEquals("11", original.getValue("1"));
  assertEquals("nullORIG", original.getValue(null));
}

@Test
public void testPutAll_nullKeyInSmallAdditional() throws Exception {
  final SortedArrayStringMap original = new SortedArrayStringMap();
  original.putValue("a", "aORIG");
  original.putValue("b", "bORIG");
  original.putValue("c", "cORIG");
  original.putValue("d", "dORIG");
  original.putValue("e", "eORIG");
  final SortedArrayStringMap other = new SortedArrayStringMap();
  other.putValue(null, "nullNEW");
  other.putValue("1", "11");
  other.putValue("a", "aa");
  original.putAll(other);
  assertEquals("size after put other", 7, original.size());
  assertEquals("aa", original.getValue("a"));
  assertEquals("bORIG", original.getValue("b"));
  assertEquals("cORIG", original.getValue("c"));
  assertEquals("dORIG", original.getValue("d"));
  assertEquals("eORIG", original.getValue("e"));
  assertEquals("11", original.getValue("1"));
  assertEquals("nullNEW", original.getValue(null));
}

Javadoc

The number of key-value mappings contained in this map.

Popular methods of SortedArrayStringMap

<init>
putValue
getKeyAt
getValueAt
indexOfKey
assertNoConcurrentModification
assertNotFrozen
ceilingNextPowerOfTwo
Calculate the next power of 2, greater than or equal to x. From Hacker's Delight, Chapter 3, Harry S
ensureCapacity
handleSerializationException
hashCode
inflateTable
Inflates the table.

Popular in Java

Start an intent from android
scheduleAtFixedRate (ScheduledExecutorService)
requestLocationUpdates (LocationManager)
startActivity (Activity)
ObjectMapper (com.fasterxml.jackson.databind)
ObjectMapper provides functionality for reading and writing JSON, either to and from basic POJOs (Pl
KeyStore (java.security)
KeyStore is responsible for maintaining cryptographic keys and their owners. The type of the syste
Queue (java.util)
A collection designed for holding elements prior to processing. Besides basic java.util.Collection o
SortedMap (java.util)
A map that has its keys ordered. The sorting is according to either the natural ordering of its keys
Stack (java.util)
Stack is a Last-In/First-Out(LIFO) data structure which represents a stack of objects. It enables u
Reference (javax.naming)
Best IntelliJ plugins

How to use sizemethodin org.apache.logging.log4j.util.SortedArrayStringMap

Best Java code snippets using org.apache.logging.log4j.util.SortedArrayStringMap.size (Showing top 20 results out of 315)

How to use
size
method
in
org.apache.logging.log4j.util.SortedArrayStringMap