package com.example.spel.util;

import lombok.Builder;
import lombok.Value;
import org.springframework.expression.BeanResolver;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.ParserContext;
import org.springframework.expression.common.TemplateParserContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.util.CollectionUtils;

import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

@Value
@Builder
public class SpelEvaluator {

  private static final ParserContext PARSER_CONTEXT = new TemplateParserContext();

  private static final ExpressionParser EXPRESSION_PARSER = new SpelExpressionParser();

  @Builder.Default
  ParserContext parserContext = PARSER_CONTEXT;

  @Builder.Default
  ExpressionParser expressionParser = EXPRESSION_PARSER;

  BeanResolver beanResolver;

  public <T> T evaluate(String spel, Object rootObject, Map<String, Object> variables) {
    StandardEvaluationContext evaluationContext = new StandardEvaluationContext(rootObject);
    if (!CollectionUtils.isEmpty(variables)) {
      evaluationContext.setVariables(variables);
    }
    if (beanResolver != null) {
      evaluationContext.setBeanResolver(beanResolver);
    }
    return evaluate(spel, evaluationContext);
  }

  @SuppressWarnings("unchecked")
  public <T> T evaluate(String spel, EvaluationContext evaluationContext) {
    Expression expression = expressionParser.parseExpression(spel, parserContext);
    return (T) expression.getValue(evaluationContext);
  }

  public MultiSpelEvaluator.MultiSpelEvaluatorBuilder multiSpel() {
    return MultiSpelEvaluator.builder().evaluator(this);
  }

  public <T> Supplier<T> supplier(String spel) {
    return () -> evaluate(spel, null, null);
  }

  public <T> Predicate<T> predicate(String key, String spel) {
    return (t) -> evaluate(spel, null, Collections.singletonMap(key, t));
  }

  public <T, R> Function<T, R> function(String key, String spel) {
    return (t) -> evaluate(spel, null, Collections.singletonMap(key, t));
  }

  public <T> BinaryOperator<T> binaryOperator(String key1, String key2, String spel) {
    return (t, u) -> evaluate(spel, null, mapOfNullable(key1, t, key2, u));
  }

  public <T> Consumer<T> consumer(String key, String spel) {
    return (t) -> evaluate(spel, null, Collections.singletonMap(key, t));
  }

  public <T, U> BiConsumer<T, U> biConsumer(String key1, String key2, String spel) {
    return (t, u) -> evaluate(spel, null, mapOfNullable(key1, t, key2, u));
  }

  private static <K, V> Map<K, V> mapOfNullable(K key1, V value1, K key2, V value2) {
    Map<K, V> map = new LinkedHashMap<>();
    map.put(key1, value1);
    map.put(key2, value2);
    return map;
  }
}

package com.example.spel.util;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.expression.BeanFactoryResolver;

@Configuration
public class BeanConfig {

  @Bean("spel")
  public SpelEvaluator spelEvaluator(ApplicationContext applicationContext) {
    return SpelEvaluator.builder().beanResolver(new BeanFactoryResolver(applicationContext)).build();
  }
}

package com.example.spel.util;

import lombok.Builder;
import lombok.Value;

import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

@Value
@Builder
public class MultiSpelEvaluator {

  SpelEvaluator evaluator;

  List<Map.Entry<String, String>> variableNameAndSpelList;

  @SuppressWarnings("unchecked")
  public <T> T evaluate(Object rootObject) {
    Map<String, Object> results = new LinkedHashMap<>();
    Object result = null;
    for (Map.Entry<String, String> input : variableNameAndSpelList) {
      result = evaluator.evaluate(input.getValue(), rootObject, results);
      results.put(input.getKey(), result);
    }
    return (T) result;
  }

  public static class MultiSpelEvaluatorBuilder {

    public MultiSpelEvaluatorBuilder add(String variableName, String spel) {
      if (this.variableNameAndSpelList == null) {
        this.variableNameAndSpelList = new ArrayList<>();
      }
      this.variableNameAndSpelList.add(new AbstractMap.SimpleImmutableEntry<>(variableName, spel));
      return this;
    }
  }
}

package com.example.spel.util;

import lombok.AccessLevel;
import lombok.Builder;
import lombok.Getter;
import lombok.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.expression.BeanExpressionContextAccessor;
import org.springframework.context.expression.BeanFactoryAccessor;
import org.springframework.context.expression.EnvironmentAccessor;
import org.springframework.context.expression.MapAccessor;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.expression.BeanResolver;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.ParserContext;
import org.springframework.expression.PropertyAccessor;
import org.springframework.expression.common.TemplateParserContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.expression.spel.support.StandardTypeConverter;
import org.springframework.expression.spel.support.StandardTypeLocator;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ConcurrentReferenceHashMap;
import org.springframework.util.StringUtils;

import java.lang.reflect.Method;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

@Value
@Builder
@Getter(AccessLevel.NONE)
public class SpelEvaluator {

  public static final String DEFAULT_INHERIT_VARIABLES_KEY = "inheritVariables";

  public static final String DEFAULT_INHERIT_FUNCTIONS_KEY = "inheritFunctions";

  private static final ParserContext PARSER_CONTEXT = new TemplateParserContext();

  private static final ExpressionParser EXPRESSION_PARSER = new SpelExpressionParser();

  private static final List<PropertyAccessor> PROPERTY_ACCESSORS = List.of(
      new BeanExpressionContextAccessor(),
      new BeanFactoryAccessor(),
      new MapAccessor(),
      new EnvironmentAccessor()
  );

  @Builder.Default
  ParserContext parserContext = PARSER_CONTEXT;

  @Builder.Default
  ExpressionParser expressionParser = EXPRESSION_PARSER;

  ConfigurableBeanFactory beanFactory;

  BeanResolver beanResolver;

  @Builder.Default
  String inheritVariablesKey = DEFAULT_INHERIT_VARIABLES_KEY;

  @Builder.Default
  String inheritFunctionsKey = DEFAULT_INHERIT_FUNCTIONS_KEY;

  // StandardBeanExpressionResolverではExpressionをConcurrentHashMapでキャッシュしていましたが、
  // Spring Framework内でキャッシュとして多用されているのはConcurrentReferenceHashMapなのでこちらを用います.
  // 作成されたバージョンを見るとConcurrentReferenceHashMapが用意される前に
  // StandardBeanExpressionResolverが作られていたようなので、
  // おそらく当初の実装から差し替えていないだけであると思われます.
  Map<String, Expression> expressionCache = new ConcurrentReferenceHashMap<>(256);

  public <T> T evaluate(String spel, Map<String, Object> variables) {
    return evaluate(spel, null, variables, null);
  }

  public <T> T evaluate(String spel,
                        Object rootObject,
                        Map<String, Object> variables) {
    return evaluate(spel, rootObject, variables, null);
  }

  public <T> T evaluate(String spel,
                        Object rootObject,
                        Map<String, Object> variables,
                        Map<String, Method> functions) {
    // 引継ぎキーワードの指定があって、なおかつSpEL内に引継ぎキーワードが出現しているかどうかで
    // 引継ぎ設定を施すかどうかを判断します.
    boolean requireInheritVariables
        = StringUtils.hasText(inheritVariablesKey) && spel.contains(inheritVariablesKey);
    boolean requireInheritFunctions
        = StringUtils.hasText(inheritFunctionsKey) && spel.contains(inheritFunctionsKey);
    return evaluate(spel, createAndConfigureEvaluationContext(
        rootObject, variables, functions, requireInheritVariables, requireInheritFunctions));
  }

  @SuppressWarnings("unchecked")
  public <T> T evaluate(String spel, EvaluationContext evaluationContext) {
    // StandardBeanExpressionResolverではSpEL文字列のパース結果であるExpressionをセットにしてキャッシュしています.
    // StandardBeanExpressionResolverのコードとは異なりますが、全く同じ処理です.
    Expression expression = expressionCache.computeIfAbsent(
        spel, s -> expressionParser.parseExpression(s, parserContext));
    return (T) expression.getValue(evaluationContext);
  }

  public StandardEvaluationContext createAndConfigureEvaluationContext(Object rootObject,
                                                                       Map<String, Object> variables,
                                                                       Map<String, Method> functions,
                                                                       boolean requireInheritVariables,
                                                                       boolean requireInheritFunctions) {

    // 複数SpEL（MultiSpelEvaluator）クラスのSpEL評価メソッドの呼び出しを記述したSpELを
    // 当クラスの評価メソッドで評価する場合、SpELの入れ子評価を行うことになります.
    // その際に、当クラスの評価メソッド（親）に対して渡された引数「rootObject」と「variables」と「functions」を
    // 複数SpEL（MultiSpelEvaluator）クラスのSpEL評価メソッド（子）の引数へ引き継いでおきたいですよね.
    // そして、複数SpEL（MultiSpelEvaluator）クラスのSpEL評価メソッド（子）内部の処理では、
    // さらに当クラスの評価呼び出しメソッドを呼び出しており、そこでさらに引き継がれて再帰的に呼び出されます.
    // 「rootObject」は「#root」と記述することで引き継ぐことができますが、
    // 「variables」と「functions」の引継ぎができません.
    // そこで、この再帰呼び出しへの引継ぎを可能にするために、
    // 「variables」に対して、「variables」自身と「functions」の2つを
    // それぞれ特定のキー（inheritVariables、inheritFunctions）で丸ごと加えておいて、
    // 複数SpEL（MultiSpelEvaluator）クラスのSpEL評価メソッド（子）呼び出し時に
    // 特定のキーを指定して取り出すことで実現させます.
    // 例えば、複数SpEL（MultiSpelEvaluator）クラスのSpEL評価メソッドを
    // evaluate(#root, #inheritVariables, #inheritFunctions)
    // と記述して呼び出すことで引継ぎできるようになります.
    // この特定のキーは、元々のvariablesのMapに対して意図せぬ上書きが発生しにくくなるように、
    // 他では使わないような名称にします.
    // 他にもThreadLocalを使って引き継ぐ方法も考えられますが、この方法の方がシンプルで分かりやすいです.
    Map<String, Object> inheritVariables = (requireInheritVariables || requireInheritFunctions)
        ? (CollectionUtils.isEmpty(variables) ? new HashMap<>() : new HashMap<>(variables))
        : variables;

    if (requireInheritVariables) {
      // SpEL入れ子評価する場合のvariables引継ぎ設定
      // 値がnullの場合、StandardEvaluationContextのsetVariableメソッドでの内部処理でキーごと削除されてしまいます.
      // SpELでキーを指定した際に参照エラーになってしまうのを回避するためnullセーフ対策をしています.
      inheritVariables.put(inheritVariablesKey, variables == null ? Collections.emptyMap() : variables);
    }

    if (requireInheritFunctions) {
      // SpEL入れ子評価する場合のfunctions引継ぎ設定
      inheritVariables.put(inheritFunctionsKey, functions == null ? Collections.emptyMap() : functions);
    }

    return configureEvaluationContext(createEvaluationContext(rootObject, inheritVariables, functions));
  }

  public StandardEvaluationContext createEvaluationContext(Object rootObject,
                                                           Map<String, Object> variables,
                                                           Map<String, Method> functions) {

    // ここに指定したオブジェクトは、SpELで「#root」というキーワードでアクセスできます.
    StandardEvaluationContext context = new StandardEvaluationContext(rootObject);

    if (!CollectionUtils.isEmpty(variables)) {
      // SpELで「#登録した名称」と書くことでMap値にアクセスできるようになります.
      // 登録した名称とは、ここではメソッド引数variablesのMapキーということになります.
      variables.forEach(context::setVariable);
    }

    if (!CollectionUtils.isEmpty(functions)) {
      // staticメソッドはSpELにて「T(FQCN).メソッド名(カンマ「,」区切りで引数列挙)」と記述すれば呼び出せます.
      // しかし、FQCN部分の記述量が長くなりがちで、これが何度も出てくると煩わしいです.
      // そこで、registerFunctionを使ってMethodを登録しておくと、
      // 「#登録した名称(カンマ「,」区切りで引数列挙)」のように簡略化した記述で呼び出せるようになります.
      // 登録した名称とは、ここではメソッド引数functionsのMapキーということになります.
      functions.forEach(context::registerFunction);
    }

    return context;
  }

  /**
   * @see org.springframework.context.expression.StandardBeanExpressionResolver#evaluate(String,
   * org.springframework.beans.factory.config.BeanExpressionContext)
   */
  public StandardEvaluationContext configureEvaluationContext(StandardEvaluationContext context) {
    // ここでは、Spring Framework基盤におけるSpEL評価で用いられている
    // StandardBeanExpressionResolverクラスで行っている
    // StandardEvaluationContextへの設定と同等の設定を行っています.
    // ここでは不変クラスであると断言できるもののみシングルトンで保持して使いまわしています.
    // 各PropertyAccessorクラスは状態を持っていないため不変クラスです.
    PROPERTY_ACCESSORS.forEach(context::addPropertyAccessor);
    if (beanResolver != null) {
      context.setBeanResolver(beanResolver);
    }
    if (beanFactory != null) {
      context.setTypeLocator(new StandardTypeLocator(beanFactory.getBeanClassLoader()));
      context.setTypeConverter(new StandardTypeConverter(() -> {
        ConversionService cs = beanFactory.getConversionService();
        return (cs != null ? cs : DefaultConversionService.getSharedInstance());
      }));
    }
    return context;
  }

  public MultiSpelEvaluator.MultiSpelEvaluatorBuilder multiSpel() {
    return MultiSpelEvaluator.builder().evaluator(this);
  }

  public <T> Supplier<T> supplier(String spel) {
    return () -> evaluate(spel, Collections.emptyMap());
  }

  // 各Functional Interfaceに対してパラメータ引継ぎ用のメソッドを追加しています.
  public <T> Supplier<T> supplier(String spel,
                                  Object rootObject,
                                  Map<String, Object> variables,
                                  Map<String, Method> functions) {
    return () -> evaluate(spel, rootObject, variables, functions);
  }

  public <T> Predicate<T> predicate(String key, String spel) {
    return (t) -> evaluate(spel, Collections.singletonMap(key, t));
  }

  public <T> Predicate<T> predicate(String key, String spel,
                                    Object rootObject,
                                    Map<String, Object> variables,
                                    Map<String, Method> functions) {
    return (t) -> evaluate(spel, rootObject, addMap(variables, key, t), functions);
  }

  public <T, R> Function<T, R> function(String key, String spel) {
    return (t) -> evaluate(spel, Collections.singletonMap(key, t));
  }

  public <T, R> Function<T, R> function(String key, String spel,
                                        Object rootObject,
                                        Map<String, Object> variables,
                                        Map<String, Method> functions) {
    return (t) -> evaluate(spel, rootObject, addMap(variables, key, t), functions);
  }

  public <T> BinaryOperator<T> binaryOperator(String key1, String key2, String spel) {
    return (t, u) -> evaluate(spel, mapOfNullable(key1, t, key2, u));
  }

  public <T> BinaryOperator<T> binaryOperator(String key1, String key2, String spel,
                                              Object rootObject,
                                              Map<String, Object> variables,
                                              Map<String, Method> functions) {
    return (t, u) -> evaluate(spel, rootObject, addMap(variables, key1, t, key2, u), functions);
  }

  public <T> Consumer<T> consumer(String key, String spel) {
    return (t) -> evaluate(spel, Collections.singletonMap(key, t));
  }

  public <T> Consumer<T> consumer(String key, String spel,
                                  Object rootObject,
                                  Map<String, Object> variables,
                                  Map<String, Method> functions) {
    return (t) -> evaluate(spel, rootObject, addMap(variables, key, t), functions);
  }

  public <T, U> BiConsumer<T, U> biConsumer(String key1, String key2, String spel) {
    return (t, u) -> evaluate(spel, mapOfNullable(key1, t, key2, u));
  }

  public <T, U> BiConsumer<T, U> biConsumer(String key1, String key2, String spel,
                                            Object rootObject,
                                            Map<String, Object> variables,
                                            Map<String, Method> functions) {
    return (t, u) -> evaluate(spel, rootObject, addMap(variables, key1, t, key2, u), functions);
  }

  private static <K, V> Map<K, V> mapOfNullable(K key1, V value1, K key2, V value2) {
    Map<K, V> map = new HashMap<>();
    map.put(key1, value1);
    map.put(key2, value2);
    return map;
  }

  private static <K, V> Map<K, V> addMap(Map<K, V> map, K key, V value) {
    Map<K, V> mutableMap = CollectionUtils.isEmpty(map) ? new HashMap<>() : new HashMap<>(map);
    mutableMap.put(key, value);
    return mutableMap;
  }

  private static <K, V> Map<K, V> addMap(Map<K, V> map, K key1, V value1, K key2, V value2) {
    Map<K, V> mutableMap = CollectionUtils.isEmpty(map) ? new HashMap<>() : new HashMap<>(map);
    mutableMap.put(key1, value1);
    mutableMap.put(key2, value2);
    return mutableMap;
  }
}

package com.example.spel.util;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.expression.BeanFactoryResolver;

@Configuration
public class BeanConfig {

  // 実装の便宜上、引数をApplicationContextから型をConfigurableBeanFactoryに変更しました.
  // 型をどちらにしていてもDIコンテナそのものがDIされることに変わりありません.
  @Bean("spel")
  public SpelEvaluator spelEvaluator(ConfigurableBeanFactory beanFactory) {
    return SpelEvaluator.builder()
        .beanFactory(beanFactory)
        // ここでは、Spring Framework基盤におけるSpEL評価で用いられている
        // StandardBeanExpressionResolverクラスで行っている
        // StandardEvaluationContextへの設定と同等の設定となるようにBeanResolverを用意しています.
        // やはりBeanFactoryResolverにDIコンテナをセットする使い方で合っていたようです.
        .beanResolver(new BeanFactoryResolver(beanFactory))
        .build();
  }
}

package com.example.spel.util;

import lombok.AccessLevel;
import lombok.Builder;
import lombok.Getter;
import lombok.Value;
import org.springframework.util.CollectionUtils;

import java.lang.reflect.Method;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Value
@Builder
@Getter(AccessLevel.NONE)
public class MultiSpelEvaluator {

  SpelEvaluator evaluator;

  List<Map.Entry<String, String>> variableNameAndSpelList;

  public <T> T evaluate(Object rootObject) {
    return evaluate(rootObject, null, null);
  }

  @SuppressWarnings("unchecked")
  public <T> T evaluate(Object rootObject,
                        Map<String, Object> variables,
                        Map<String, Method> functions) {
    Map<String, Object> results = CollectionUtils.isEmpty(variables)
        ? new HashMap<>() : new HashMap<>(variables);
    Object result = null;
    for (Map.Entry<String, String> input : variableNameAndSpelList) {
      result = evaluator.evaluate(input.getValue(), rootObject, results, functions);
      results.put(input.getKey(), result);
    }
    return (T) result;
  }

  public static class MultiSpelEvaluatorBuilder {

    public MultiSpelEvaluatorBuilder add(String variableName, String spel) {
      if (this.variableNameAndSpelList == null) {
        this.variableNameAndSpelList = new ArrayList<>();
      }
      this.variableNameAndSpelList.add(new AbstractMap.SimpleImmutableEntry<>(variableName, spel));
      return this;
    }

    private MultiSpelEvaluatorBuilder variableNameAndSpelList(
        List<Map.Entry<String, String>> variableNameAndSpelList) {
      throw new UnsupportedOperationException();
    }

    public MultiSpelEvaluator build() {
      return new MultiSpelEvaluator(this.evaluator, Collections.unmodifiableList(this.variableNameAndSpelList));
    }
  }
}

package com.example.spel.util;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.util.ReflectionUtils;

import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.BiFunction;
import java.util.stream.Stream;

@SpringBootTest
@ExtendWith(SpringExtension.class)
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class SpelEvaluatorTest {

  // @Valueアノテーション内のSpELから参照できるようにするために意図的にpublicにしてあります
  public static final List<String> TEST_DATA
      = List.of("hello,", "spring", "expression", "language", "(spel)!");

  public static final Map<String, Object> TEST_VARIABLES = Map.of(
      "list", List.of("hello,", "spring", "expression", "language", "(spel)!")
  );

  public static final Map<String, Method> TEST_FUNCTIONS = Map.of("concat",
      ReflectionUtils.findMethod(SpelEvaluatorTest.class, "concatWithSpace", String.class, String.class));

  public static String concatWithSpace(String s1, String s2) {
    return s1 + " " + s2;
  }

  @Autowired
  private SpelEvaluator evaluator;

  // 1. SpEL内でlambda式を使いたい
  @Value("""
      #{T(com.example.spel.util.SpelEvaluatorTest).TEST_DATA.stream()
      .map(@spel.function('s', '#{#s.toUpperCase()}'))
      .reduce(@spel.binaryOperator('a', 'v', '#{#a + '' '' + #v}'))
      .get()}""")
  private String valueAnnotationEvaluatedValue1;

  // 2. 複数SpELを使いたい
  @Value("""
      #{@spel.multiSpel()
      .add('stream1', '#{#root.stream()}')
      .add('stream2', '#{#stream1.map(@spel.function(''s'', ''#{#s.toUpperCase()}''))}')
      .add('optional',
      '#{#stream2.reduce(@spel.binaryOperator(''a'', ''v'', ''#{#a + '''' '''' + #v}''))}')
      .add('result', '#{#optional.get()}')
      .build()
      .evaluate(T(com.example.spel.util.SpelEvaluatorTest).TEST_DATA)}""")
  private String valueAnnotationEvaluatedValue2;

  // 3. 複数SpELを使いたい（variablesやfunctionを引き継いで使いたい）
  @Value("""
      #{@spel.multiSpel()
      .add('stream1', '#{#list.stream()}')
      .add('stream2', '#{#stream1.map(@spel.function(''s'', ''#{#s.toUpperCase()}''))}')
      .add('optional', '#{#stream2.reduce(@spel.binaryOperator
      (''a'', ''v'', ''#{#concat(#a, #v)}'', #root, #inheritVariables, #inheritFunctions))}')
      .add('result', '#{#optional.get()}')
      .build()
      .evaluate(null,
      T(com.example.spel.util.SpelEvaluatorTest).TEST_VARIABLES,
      T(com.example.spel.util.SpelEvaluatorTest).TEST_FUNCTIONS)}""")
  private String valueAnnotationEvaluatedValue3;

  @DisplayName("testEvaluate")
  @ParameterizedTest(name = "{0}")
  @MethodSource("testEvaluateParameterProvider")
  void testEvaluate(String display,
                    String spel,
                    Object root,
                    Map<String, Object> variables,
                    Map<String, Method> functions,
                    BiFunction<Object, Map<String, Object>, ?> expectedProcess,
                    String valueAnnotationEvaluatedValue,
                    Object expectedResult) {
    // プログラム的に明示的に行ったSpEL文字列評価結果の検証
    Assertions.assertEquals(expectedResult, evaluator.evaluate(spel, root, variables, functions));
    // 参考までにSpEL文字列相当の実コードをBiFunctionに封じ込めて実行した結果
    Assertions.assertEquals(expectedResult, expectedProcess.apply(root, variables));
    // @Valueアノテーション内のSpEL文字列評価結果（＝フィールドにバインドされた値）の検証
    Assertions.assertEquals(expectedResult, valueAnnotationEvaluatedValue);
  }

  @SuppressWarnings("unchecked")
  Stream<Arguments> testEvaluateParameterProvider() {
    return Stream.of(
        Arguments.of(
            "1. SpEL内でlambda式を使いたい", // display
            """
                #{#root.stream()
                .map(@spel.function('s', '#{#s.toUpperCase()}'))
                .reduce(@spel.binaryOperator('a', 'v', '#{#a + '' '' + #v}'))
                .get()}""", // spel
            TEST_DATA, // root
            null, // variables
            null, // functions
            (BiFunction<Object, Map<String, Object>, ?>) (root, variables) ->
                ((List<String>) root).stream()
                    .map(s -> s.toUpperCase())
                    .reduce((a, v) -> a + " " + v)
                    .get(), // expectedProcess
            this.valueAnnotationEvaluatedValue1, // valueAnnotationEvaluatedValue
            "HELLO, SPRING EXPRESSION LANGUAGE (SPEL)!" // expectedResult
        ),
        Arguments.of(
            "2. 複数SpELを使いたい", // display
            """
                #{@spel.multiSpel()
                .add('stream1', '#{#root.stream()}')
                .add('stream2', '#{#stream1.map(@spel.function(''s'', ''#{#s.toUpperCase()}''))}')
                .add('optional',
                '#{#stream2.reduce(@spel.binaryOperator(''a'', ''v'', ''#{#a + '''' '''' + #v}''))}')
                .add('result', '#{#optional.get()}')
                .build()
                .evaluate(#root)}""", // spel
            TEST_DATA, // root
            null, // variables
            null, // functions
            (BiFunction<Object, Map<String, Object>, ?>) (root, variables) ->
            {
              Stream<String> stream1 = ((List<String>) root).stream();
              Stream<String> stream2 = stream1.map(s -> s.toUpperCase());
              Optional<String> optional = stream2.reduce((a, v) -> a + " " + v);
              String result = optional.get();
              return result;
            }, // expectedProcess
            this.valueAnnotationEvaluatedValue2, // valueAnnotationEvaluatedValue
            "HELLO, SPRING EXPRESSION LANGUAGE (SPEL)!" // expectedResult
        ),
        Arguments.of(
            "3. 複数SpELを使いたい（variablesやfunctionを引き継いで使いたい）", // display
            """
                #{@spel.multiSpel()
                .add('stream1', '#{#list.stream()}')
                .add('stream2', '#{#stream1.map(@spel.function(''s'', ''#{#s.toUpperCase()}''))}')
                .add('optional', '#{#stream2.reduce(@spel.binaryOperator
                (''a'', ''v'', ''#{#concat(#a, #v)}'', #root, #inheritVariables, #inheritFunctions))}')
                .add('result', '#{#optional.get()}')
                .build()
                .evaluate(#root, #inheritVariables, #inheritFunctions)}""", // spel
            null, // root
            TEST_VARIABLES, // variables
            TEST_FUNCTIONS, // functions
            (BiFunction<Object, Map<String, Object>, ?>) (root, variables) ->
            {
              Stream<String> stream1 = ((List<String>) variables.get("list")).stream();
              Stream<String> stream2 = stream1.map(s -> s.toUpperCase());
              Optional<String> optional = stream2.reduce((a, v) -> concatWithSpace(a, v));
              String result = optional.get();
              return result;
            }, // expectedProcess
            this.valueAnnotationEvaluatedValue3, // valueAnnotationEvaluatedValue
            "HELLO, SPRING EXPRESSION LANGUAGE (SPEL)!" // expectedResult
        )
    );
  }
}