Map<String, Object> inner = new HashMap<>();
        inner.put("innerKey", "innerValue");

        Map<String, Object> map = new HashMap<>();
        map.put("nested", inner);

        Map<String, Object> result = MapValueExtractor.getMap(map, "nested");
        assertNotNull(result);
        assertEquals("innerValue", result.get("innerKey"));

        assertNull(MapValueExtractor.getMap(map, "missing"));
    }

            }
        };

        // Test with nested parameters
        Map<String, Object> nestedParams = new HashMap<>();
        Map<String, Object> innerMap = new HashMap<>();
        innerMap.put("innerKey", "innerValue");
        nestedParams.put("nested", innerMap);

        assertNotNull(queryRescorer.evaluate(nestedParams));

        // Test without nested parameters
        Map<String, Object> flatParams = new HashMap<>();

        // Create inner BooleanQuery
        BooleanQuery.Builder innerBoolQueryBuilder = new BooleanQuery.Builder();
        TermQuery innerTermQuery = new TermQuery(new Term("innerField", "innerValue"));
        innerBoolQueryBuilder.add(innerTermQuery, BooleanClause.Occur.MUST);
        BooleanQuery innerBooleanQuery = innerBoolQueryBuilder.build();

        // Create outer BooleanQuery

  }

  public static <T> GenericClass<T> getStaticAnonymousClass(T value) {
    return new GenericClass<T>() {
      @Keep public final T innerValue = value;
    };
  }

  private interface ListIterable<T> extends Iterable<List<T>> {}

  private interface StringListIterable extends ListIterable<String> {}

  }

  public static <T> GenericClass<T> getStaticAnonymousClass(T value) {
    return new GenericClass<T>() {
      @Keep public final T innerValue = value;
    };
  }

  private interface ListIterable<T> extends Iterable<List<T>> {}

  private interface StringListIterable extends ListIterable<String> {}