linksOption.getValue().add(extDocUrl)

        when:
        linksOption.writeCollectionValue(writerContextMock)

        then:
        1 * writerContextMock.writeMultilineValuesOption(optionName, [extDocUrl])
    }

    def writeMultipleValues() {
        final String docUrl1 = "docUrl1"
        final String docUrl2 = "docUrl2"

        linksOption.getValue().add(docUrl1)

                return false;
            }
        }
        return true;
    }

    private boolean compareTrivialEntries(ChangeVisitor visitor, Map.Entry<String, S> previousEntry, Map.Entry<String, S> currentEntry, String propertyTitle) {
        S previous = previousEntry.getValue();
        S current = currentEntry.getValue();

        try {
            writer.write("class " + className + " {");
            writer.write("    String getValue() { return \\"");
            String messageFromOptions = options.get("message");
            if (messageFromOptions == null) {
                writer.write(HelperUtil.getValue() + "${suffix}");
            } else {
                writer.write(messageFromOptions);
            }

        final String valueTwo = "valueTwo"

        stringsOption.getValue().add(valueOne)
        stringsOption.getValue().add(valueTwo)

        when:
        stringsOption.write(writerContextMock)

        then:
        1 * writerContextMock.writeValuesOption(optionName, stringsOption.getValue(), joinBy)
    }

        map.put("boost2", 0);
        assertTrue(0.0f == docBoostMatcher.getValue(map));

        map.put("boost1", 1);
        map.put("boost2", 0);
        assertTrue(10.0f == docBoostMatcher.getValue(map));

        map.put("boost1", 1);
        map.put("boost2", 2);
        assertTrue(12.0f == docBoostMatcher.getValue(map));
    }

    public ValueSnapshot asSnapshot() {
        return this;
    }

    @Override
    public T isolate() {
        return getValue();
    }

    @Nullable
    @Override
    public <S> S coerce(Class<S> type) {
        if (type.isInstance(getValue())) {
            return type.cast(getValue());
        }
        return null;
    }

        super(value);
        this.classLoaderHasher = classLoaderHasher;
    }

    @Override
    public void appendToHasher(Hasher hasher) {
        hasher.putString(getValue().getName());
        Class<?> type = getValue().getType();
        ImplementationSnapshot.of(type, classLoaderHasher).appendToHasher(hasher);
    }

        if (expression.getType() == IncludeType.IDENTIFIER) {
            return new SimpleExpression(expression.getValue(), IncludeType.MACRO);
        }
        if (expression.getType() == IncludeType.TOKEN_CONCATENATION) {
            return new ComplexExpression(IncludeType.EXPAND_TOKEN_CONCATENATION, expression.getValue(), expression.getArguments());
        }

      this.samples =
          new SampleElements<>(
              mapSamples.e0().getValue(),
              mapSamples.e1().getValue(),
              mapSamples.e2().getValue(),
              mapSamples.e3().getValue(),
              mapSamples.e4().getValue());
    }

    @Override
    public SampleElements<V> samples() {
      return samples;
    }

    @Override

    ImmutableMap<C, V> row = rowEntry.getValue();
    int columnIndex = cellColumnInRowIndices[index];
    Entry<C, V> colEntry = row.entrySet().asList().get(columnIndex);
    return cellOf(rowEntry.getKey(), colEntry.getKey(), colEntry.getValue());
  }

  @Override
  V getValue(int index) {
    int rowIndex = cellRowIndices[index];