/**
     * Returns a filtered list of class path elements. This method is invoked when the caller
     * requested that all dependencies are placed on the class path, with no module path element.
     *
     * @param scopeFilter a filter returning {@code true} for the artifact scopes to accept
     * @param includeTestDir whether to include the test directory in the classpath elements
     * @return paths of all artifacts placed on the classpath

                        Version.BASE,
                        "parent.artifactId",
                        null,
                        "must be changed"
                                + ", the parent element cannot have the same groupId:artifactId as the project.",
                        parent);
            }

            if (equals("LATEST", parent.getVersion()) || equals("RELEASE", parent.getVersion())) {

                 * are ignored if the POM file contains at least one <source> element
                 * for the corresponding scope and language. This rule exists because
                 * Maven provides default values for those elements which may conflict
                 * with user's configuration.
                 */
                if (!hasScript) {

		                          </Rule>
		                          </LifecycleConfiguration>`,
			expectedParsingErr:    nil,
			expectedValidationErr: nil,
		},
		{ // Using ExpiredObjectAllVersions element with an object locked bucket
			inputConfig: `<LifecycleConfiguration>
                                        <Rule>
                                          <ID>ExpiredObjectAllVersions with object locking</ID>

		apiErr = ErrEventNotification
	case *event.ErrInvalidARN:
		apiErr = ErrARNNotification
	case *event.ErrARNNotFound:
		apiErr = ErrARNNotification
	case *levent.ErrInvalidARN:
		apiErr = ErrLambdaARNInvalid
	case *levent.ErrARNNotFound:
		apiErr = ErrLambdaARNNotFound
	case *event.ErrUnknownRegion:
		apiErr = ErrRegionNotification
	case *event.ErrInvalidFilterName:
		apiErr = ErrFilterNameInvalid

//
// ``delete``: This is the delete-marker
//
// ``legacyObject``: This is the legacy object in xlV1 format, preserved until its overwritten
//
// The most recently updated element in the array is considered the latest version.

// In addition to these we have a special kind called free-version. This is represented
// using a delete-marker and MetaSys entries. It's used to track tiered content of a

// `oper` and `num_dims` with the corresponding number of dimensions. On return,
// for every i where `num_dims[i]` > 0, `dims[i]` will be an array of
// `num_dims[i]` elements. A value of -1 for `num_dims[i]` indicates that the
// i-th shape in the list is unknown.
//
// The elements of `dims` will point to addresses in `storage` which must be
// large enough to hold at least `storage_size` int64_ts.  Ideally, `num_shapes`

    // The following input string length is large enough to make sure that
    // copy to tstring in large mode.
    std::string source =
        "This is the " + std::to_string(i + 1) + "th. data element\n";
    TF_TString_Copy(&data[i], source.c_str(), source.length());
  }

  TF_DeleteTensor(t);
}

}  // namespace
}  // namespace tensorflow

// TODO(josh11b): Test:

			wantResult: `{"_1":1.5,"_2":2.5}`,
		},
		{
			name:  "limit-1",
			query: `SELECT * FROM S3Object[*].elements[*] LIMIT 1`,
			requestXML: []byte(`
<?xml version="1.0" encoding="UTF-8"?>
<SelectObjectContentRequest>
    <Expression>select * from s3object[*].elements[*] s where s.element_type = '__elem__merfu'</Expression>
    <ExpressionType>SQL</ExpressionType>
    <InputSerialization>

        assertEquals(expected, pom.getValue(expression));
    }

    private static String createPath(List<String> elements) {
        StringBuilder buffer = new StringBuilder(256);
        for (String s : elements) {
            buffer.append(s).append(File.separator);
        }
        return buffer.toString().substring(0, buffer.length() - 1);
    }