want[0] = Level3{
		Level2: Level2{
			Level1s: []Level1{
				{Value: "value1"},
				{Value: "value2"},
			},
		},
		Level2_1: Level2_1{
			Level1s: []Level1{
				{
					Value:   "value1-1",
					Level0s: []Level0{{Value: "Level0-1"}},
				},
				{
					Value:   "value2-2",
					Level0s: []Level0{{Value: "Level0-2"}},
				},
			},
		},
	}

          DeferredCloser closer,
          @ParametricNullness V1 value1,
          @ParametricNullness V2 value2,
          @ParametricNullness V3 value3,
          @ParametricNullness V4 value4,
          @ParametricNullness V5 value5)
          throws Exception;
    }

    /**
     * A function that returns a {@link ClosingFuture} when applied to the values of the five

      assertThat(cache.asMap().values()).containsExactly(value1, value2);
      assertThat(cache.asMap().entrySet())
          .containsExactly(immutableEntry(key1, value1), immutableEntry(key2, value2));
    }
  }

  public void testInvalidate() {
    for (LoadingCache<Key, String> cache : caches()) {
      Key key1 = new Key(1);
      String value1 = key1.toString();
      Key key2 = new Key(2);

      assertThat(cache.asMap().values()).containsExactly(value1, value2);
      assertThat(cache.asMap().entrySet())
          .containsExactly(immutableEntry(key1, value1), immutableEntry(key2, value2));
    }
  }

  public void testInvalidate() {
    for (LoadingCache<Key, String> cache : caches()) {
      Key key1 = new Key(1);
      String value1 = key1.toString();
      Key key2 = new Key(2);

    public void test_getFieldValues() throws Exception {
        Map<String, Object> document = new HashMap<>();
        document.put("string_field", "value1");
        document.put("string_array_field", new String[] { "value2", "value3" });
        document.put("list_field", java.util.Arrays.asList("value4", "value5"));
        document.put("int_field", 123);

        String[] stringValues = defaultContentsParser.getFieldValues(document, "string_field");

	DB.Migrator().AutoMigrate(&Preload{}, &Join{}, &Nested{}, &Value{})

	value1 := Value{
		Name: "value",
		Nested: Nested{
			Preloads: []*Preload{
				{Value: "p1"}, {Value: "p2"},
			},
			Join: Join{Value: "j1"},
		},
	}
	value2 := Value{
		Name: "value2",
		Nested: Nested{
			Preloads: []*Preload{
				{Value: "p3"}, {Value: "p4"}, {Value: "p5"},
			},

        TestBean bean2 = new TestBean();
        PlexusConfiguration config = new XmlPlexusConfiguration("test");
        config.setValue("value1");

        when(evaluator.evaluate("value1")).thenReturn("value1");
        when(evaluator.evaluate("value2")).thenReturn("value2");

        java.lang.reflect.Field field = TestBean.class.getDeclaredField("directField");

        // First access

    checkNotNull(value2);
    checkArgument(!Objects.equals(value1, value2), "Duplicate value provided.");
    distinctValues.replaceValues(type, ImmutableList.of(value1, value2));
    setDefault(type, value1);
    return this;
  }

  /**
   * Tests that {@code cls} properly checks null on all constructor and method parameters that
   * aren't annotated nullable (according to the rules of {@link NullPointerTester}). In details:
   *

        String key = "key";
        String value1 = "a";
        String value2 = "b";
        String value3 = "c";
        settings.array().add(key, value1);
        settings.array().add(key, value2);
        settings.array().add(key, value3);
        assertEquals(3, settings.array().get(key).length);
        assertEquals(value1, settings.array().get(key)[0]);
        assertEquals(value2, settings.array().get(key)[1]);

  /**
   * Sets two distinct values for {@code type}. These values can be used for both null pointer
   * testing and equals testing.
   *
   * @since 17.0
   */
  protected final <T> void setDistinctValues(Class<T> type, T value1, T value2) {
    tester.setDistinctValues(type, value1, value2);
  }

  /** Specifies that classes that satisfy the given predicate aren't tested for sanity. */