ticker.advance(EXPIRING_TIME * 10, MILLISECONDS);

    // add a single unexpired entry
    cache.getUnchecked(KEY_PREFIX + 11);

    // collections views shouldn't expose expired entries
    assertThat(Iterators.size(cache.asMap().entrySet().iterator())).isEqualTo(1);
    assertThat(Iterators.size(cache.asMap().keySet().iterator())).isEqualTo(1);
    assertThat(Iterators.size(cache.asMap().values().iterator())).isEqualTo(1);

            mavenProjectHelper.attachArtifact(mavenProject, "java-source", artifactFile);
            assertEquals(1, mavenProject.getAttachedArtifacts().size());
            mavenProjectHelper.attachArtifact(mavenProject, "java-source", artifactFile);
            assertEquals(1, mavenProject.getAttachedArtifacts().size());
        } finally {
            Files.deleteIfExists(artifactFile.toPath());
        }
    }

    }

    @Test
    public void testAddInitialSettings() {
        // Test adding single setting
        SuggestSettingsBuilder result = builder.addInitialSettings("key1", "value1");
        assertEquals(builder, result); // Test method chaining
        assertEquals(1, builder.initialSettings.size());
        assertEquals("value1", builder.initialSettings.get("key1"));

        // Test adding multiple settings

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import java.util.Map;

/**
 * An implementation of {@link ImmutableTable} that holds a single cell.
 *
 * @author Gregory Kick
 */
@GwtCompatible
final class SingletonImmutableTable<R, C, V> extends ImmutableTable<R, C, V> {
  final R singleRowKey;
  final C singleColumnKey;
  final V singleValue;

        return true;
      }
      if (object instanceof BooleanArrayAsList) {
        BooleanArrayAsList that = (BooleanArrayAsList) object;
        int size = size();
        if (that.size() != size) {
          return false;
        }
        for (int i = 0; i < size; i++) {
          if (array[start + i] != that.array[that.start + i]) {
            return false;
          }
        }
        return true;
      }

        return true;
      }
      if (object instanceof BooleanArrayAsList) {
        BooleanArrayAsList that = (BooleanArrayAsList) object;
        int size = size();
        if (that.size() != size) {
          return false;
        }
        for (int i = 0; i < size; i++) {
          if (array[start + i] != that.array[that.start + i]) {
            return false;
          }
        }
        return true;
      }

After the symbol, the arguments are flags (see below)
and the frame size, a constant (but see below):
</p>

<pre>
TEXT runtime·profileloop(SB),NOSPLIT,$8
	MOVQ	$runtime·profileloop1(SB), CX
	MOVQ	CX, 0(SP)
	CALL	runtime·externalthreadhandler(SB)
	RET
</pre>

<p>
In the general case, the frame size is followed by an argument size, separated by a minus sign.
(It's not a subtraction, just idiosyncratic syntax.)

        return localInterfaces.size() > 0 && remoteInterfaces.size() > 0
            && (localInterfaces.size() > 1 || remoteInterfaces.size() > 1);
    }
    
    private void establishAdditionalChannels() {
        int currentChannels = channels.size();
        int targetChannels = Math.min(maxChannels, 
            Math.min(localInterfaces.size(), remoteInterfaces.size()));
        

            vertices = new TreeSet<>();
        }
    }

    private void checkEdges() {
        int count = DEFAULT_EDGES;

        if (vertices != null) {
            count = vertices.size() + vertices.size() / 2;
        }

        checkEdges(count);
    }

    private void checkEdges(int nEdges) {
        if (incidentEdges == null) {
            incidentEdges = new HashMap<>(nEdges);
        }

A single HTTP call may require follow-up requests to be made to handle authentication challenges, redirects, and HTTP-layer timeouts. In such cases multiple connections, requests, and responses may be attempted. Follow-ups are another reason a single call may trigger multiple events of the same type.