Java8Compatibility.flip(buffer);

      newBuffer.put(buffer);

      // Swap references, newBuffer is already in write mode at the correct position
      this.buffer = newBuffer;
    }

    @Override
    public Hasher putByte(byte b) {
      ensureCapacity(Byte.BYTES);
      buffer.put(b);
      return this;
    }

    @Override

        buildFailuresByProject.put(getProjectKey(project), new BuildFailure(project, time, error));
    }

    public void registerBuildFailure(MavenProject project, Exception error, String task, Duration time) {
        buildFailuresByProject.put(getProjectKey(project), new BuildFailure(project, time, error));
    }

    public boolean hasBuildFailures() {

            commandExecute.put("!", new CommandMethods(this::shell, this::defaultCompleter));
            commandExecute.put("cd", new CommandMethods(this::cd, this::cdCompleter));
            commandExecute.put("pwd", new CommandMethods(this::pwd, this::defaultCompleter));
            commandExecute.put("mvn", new CommandMethods(this::mvn, this::mvnCompleter));

        this.out = (out != null) ? out : System.out;
    }

    @Override
    public void transferInitiated(TransferEvent event) {
        String message = event.getRequestType() == TransferEvent.RequestType.PUT ? "Uploading" : "Downloading";

        println(
                "transferInitiated",
                message + ": " + event.getResource().getRepositoryUrl()
                        + event.getResource().getResourceName());

    @Test
    public void test_print_parameterSorting() {
        activityHelper.useEcsFormat = false;
        Map<String, String> params = new HashMap<>();
        params.put("z_param", "z_value");
        params.put("a_param", "a_value");
        params.put("m_param", "m_value");
        activityHelper.print("test", OptionalThing.empty(), params);
        String result = localLogMsg.get();

    static {
        // unreleased major and two unreleased minors ( minor in feature freeze )
        sampleVersions.put("8.0.0", asList("7_0_0", "7_0_1", "7_1_0", "7_1_1", "7_2_0", "7_3_0", "8.0.0"));
        sampleVersions.put(
            "7.0.0-alpha1",
            asList(
                "6_0_0_alpha1",
                "6_0_0_alpha2",
                "6_0_0_beta1",

          builder.put(entry.getKey(), entry.getValue());
        }
        return builder.buildOrThrow();
      }
    },
    BUILDER_PUT_ALL_MAP {
      @Override
      public ImmutableBiMap<Object, Object> create(List<Entry<?, ?>> entries) {
        Map<Object, Object> sourceMap = new LinkedHashMap<>();
        for (Entry<?, ?> entry : entries) {
          if (sourceMap.put(entry.getKey(), entry.getValue()) != null) {

                Map<Object, Object> context = Collections.emptyMap();

                for (Plugin element : src) {
                    Object key = getPluginKey(element);
                    managedPlugins.put(key, element);
                }

                for (Plugin element : tgt) {
                    Object key = getPluginKey(element);
                    Plugin managedPlugin = managedPlugins.get(key);

    original.put(1, "foo", 'a');
    assertEquals((Character) 'a', transpose.get("foo", 1));
  }

  public void testPutTransposeModifiesOriginal() {
    Table<Integer, String, Character> original = HashBasedTable.create();
    Table<String, Integer, Character> transpose = transpose(original);
    transpose.put("foo", 1, 'a');
    assertEquals((Character) 'a', original.get(1, "foo"));

            if (pos == current) {
                newClientMap.put(Pattern.compile(regex), client);
                added = true;
            }
            newClientMap.put(entry.getKey(), entry.getValue());
            current++;
        }
        if (!added) {
            newClientMap.put(Pattern.compile(regex), client);
        }
        clientMap = newClientMap;
    }

    /**