if (!Modifier.isFinal(currentField.getModifiers())) {
                                    fields.add(new StringField(currentField));
                                }
                            } else if (List.class.isAssignableFrom(type)) {
                                fields.add(new ListField(currentField));
                            } else if (Collection.class.isAssignableFrom(type)) {

    testers.add(CollectionSerializationEqualTester.class);
    testers.add(MultisetAddTester.class);
    testers.add(MultisetContainsTester.class);
    testers.add(MultisetCountTester.class);
    testers.add(MultisetElementSetTester.class);
    testers.add(MultisetEqualsTester.class);
    testers.add(MultisetForEachEntryTester.class);
    testers.add(MultisetReadsTester.class);

    Multiset<String> ms = LinkedHashMultiset.create();
    ms.add("a", 3);
    ms.add("c", 1);
    ms.add("b", 2);

    assertThat(ms.toString()).isEqualTo("[a x 3, c, b x 2]");
  }

  public void testLosesPlaceInLine() throws Exception {
    Multiset<String> ms = LinkedHashMultiset.create();
    ms.add("a");
    ms.add("b", 2);
    ms.add("c");

	}

	// Record per connection stats.
	c.outgoingBytes = func(n int64) {
		if o.outgoingBytes != nil {
			o.outgoingBytes(n)
		}
		c.outBytes.Add(n)
	}
	c.incomingBytes = func(n int64) {
		if o.incomingBytes != nil {
			o.incomingBytes(n)
		}
		c.inBytes.Add(n)
	}
	if !strings.HasPrefix(o.remote, "https://") && !strings.HasPrefix(o.remote, "wss://") {
		c.baseFlags |= FlagCRCxxh3
	}

    the add-opens. Right now that doesn't seem worth the effort, though.
    -->
    <test.add.opens>
      --add-opens java.base/java.lang=ALL-UNNAMED
      --add-opens java.base/java.util=ALL-UNNAMED
      --add-opens java.base/sun.security.jca=ALL-UNNAMED
    </test.add.opens>
    <module.status>integration</module.status>

        NbtAddress[] addresses = (NbtAddress[]) addressArrayField.get(response);

        NbtAddress addr = addresses[0];
        assertTrue(addr.groupName);
        assertEquals(3, addr.nodeType);
        assertTrue(addr.isBeingDeleted);
        assertTrue(addr.isInConflict);
        assertTrue(addr.isActive);
        assertTrue(addr.isPermanent);
    }

    @Test

		// Coerce to well-formed UTF-8.
		default:
			d.scratch.add(c)
			if d.remaining() == 0 {
				return "", d.mkError(ErrSyntax, "in string literal")
			}
			c = d.next()
		}
	}

scan_esc:
	switch c {
	case '"', '\\', '/', '\'':
		d.scratch.add(c)
	case 'u':
		goto scan_u
	case 'b':
		d.scratch.add('\b')
	case 'f':
		d.scratch.add('\f')
	case 'n':
		d.scratch.add('\n')
	case 'r':

    Multiset<String> multiset = HashMultiset.create();
    multiset.add("foo", 2);
    multiset.add("bar");
    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));
  }

  public void testCreateWithSize() {
    Multiset<String> multiset = HashMultiset.create(50);
    multiset.add("foo", 2);
    multiset.add("bar");
    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));

        List<ColumnInfo> ls = newArrayList();
        ls.add(columnEndTime());
        ls.add(columnJobName());
        ls.add(columnJobStatus());
        ls.add(columnLastUpdated());
        ls.add(columnScriptData());
        ls.add(columnScriptResult());
        ls.add(columnScriptType());
        ls.add(columnStartTime());
        ls.add(columnTarget());
        return ls;
    }

        .add(new Striped.SmallLazyStriped<Lock>(64, ReentrantLock::new))
        .add(new Striped.LargeLazyStriped<Lock>(50, ReentrantLock::new))
        .add(new Striped.LargeLazyStriped<Lock>(64, ReentrantLock::new))
        .add(new Striped.SmallLazyStriped<Semaphore>(50, SEMAPHORE_SUPPLER))
        .add(new Striped.SmallLazyStriped<Semaphore>(64, SEMAPHORE_SUPPLER))
        .add(new Striped.LargeLazyStriped<Semaphore>(50, SEMAPHORE_SUPPLER))