// MetaContext is the KMS context provided by a client when encrypting an
	// object with SSE-KMS. A client may not send a context in which case the
	// MetaContext will not be present.
	// MetaContext only contains the bucket/object name if the client explicitly
	// added it. However, when decrypting an object the bucket/object name must
	// be part of the object. Therefore, the bucket/object name must be added

			e := t.Init(ctx)
			if e != nil {
				errs = append(errs, e)
			}
		}
	}
	return tgts, errs
}

// Split targets into two groups:
//
//	group1 contains all targets of type t
//	group2 contains the remaining targets
func splitTargets(targets []Target, t types.TargetType) (group1 []Target, group2 []Target) {
	for _, target := range targets {
		if target.Type() == t {

   *         .build();
   * }
   *
   * <p>Builder instances can be reused; it is safe to call {@link #build} multiple times to build
   * multiple multimaps in series. Each multimap contains the key-value mappings in the previously
   * created multimaps.
   *
   * @since 2.0
   */
  @DoNotMock
  public static class Builder<K, V> {
    @Nullable Map<K, ImmutableCollection.Builder<V>> builderMap;

    }

    // ===== DI Container Integration Tests =====

    /**
     * Test that DI container is available in the script
     */
    @Test
    public void test_evaluate_containerAvailable() {
        final Map<String, Object> params = new HashMap<>();
        assertNotNull(groovyEngine.evaluate("return container", params));
    }

    /**

| `terms_of_service` | `str` | A URL to the Terms of Service for the API. If provided, this has to be a URL. |

//configureJavaCompatibility(javaVersion = 8)

configureKotlinCompatibility(version = version("kotlinCoreLibrariesVersion"))

tasks.withType<JavaCompile> {
  options.encoding = Charsets.UTF_8.toString()
  if (name.contains("Java9")) {
    sourceCompatibility = "9"
    targetCompatibility = "9"
  } else {
    sourceCompatibility = "1.8"
    targetCompatibility = "1.8"
  }
}

tasks.withType<KotlinCompile> {

        ScriptEngineException exception = new ScriptEngineException(message);

        String result = exception.toString();
        assertNotNull(result);
        assertTrue(result.contains("ScriptEngineException"));
        assertTrue(result.contains(message));
    }

    @Test
    public void test_withComplexCauseChain() {
        // Test with a chain of exceptions

    assertEquals(values.size(), multimap().get(key).size());

    assertEquals(values.size() > 0, multimap().containsKey(key));
    assertEquals(values.size() > 0, multimap().keySet().contains(key));
    assertEquals(values.size() > 0, multimap().keys().contains(key));
  }

  protected final K k0() {
    return e0().getKey();
  }

  protected final V v0() {
    return e0().getValue();
  }

                () -> newModelResolver().resolveModel(parent),
                "Expected 'UnresolvableModelException' not thrown.");
        assertNotNull(e.getMessage());
        assertTrue(e.getMessage().contains("Could not find artifact ut.simple:artifact:pom:0 in repo"));
    }

    @Test
    public void testResolveParentThrowsUnresolvableModelExceptionWhenNoMatchingVersionFound() throws Exception {

    private String version;

    /**
     * Creates a new container for the specified model.
     *
     * @param model The model to wrap, may be {@code null}.
     */
    ModelData(ModelSource source, Model model) {
        this.source = source;
        this.model = model;
    }

    /**
     * Creates a new container for the specified model.
     *