file: org.apache.spark.rdd.RDD[String] = s3a://testbucket/testdata MapPartitionsRDD[1] at textFile at <console>:24

scala> val counts = file.flatMap(line => line.split(" ")).map(word => (word, 1)).reduceByKey(_ + _)
counts: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[4] at reduceByKey at <console>:25

scala> counts.saveAsTextFile("s3a://testbucket/wordcount")
```

    /** The suggest helper for managing suggest functionality. */
    @Resource
    protected SuggestHelper suggestHelper;

    /**
     * Retrieves suggest statistics including word counts.
     *
     * @return JSON response containing suggest statistics
     */
    // GET /api/admin/suggest
    @Execute
    public JsonResponse<ApiResult> get$index() {

	//	{
	//		outcode(int($1), &$2, int($4.Reg), &$6);
	//	}
	ADDD	F1, F2, F3

	//	LFCMP freg ',' freg
	//	{
	//		outcode(int($1), &$2, 0, &$4);
	//	}
	CMPEQD	F1, F2


	//
	// WORD
	//
	WORD	$1

	//
	// NOP
	//
	//	LNOP comma // asm doesn't support the trailing comma.
	//	{
	//		outcode(int($1), &nullgen, 0, &nullgen);
	//	}
	NOP

        assertEquals(4, list.size());
        assertEquals("test1", list.get(0).getInput());
        assertEquals("日本語", list.get(1).getInput());
        assertEquals("word with spaces", list.get(2).getInput());
        assertEquals("	tab	word	", list.get(3).getInput());
    }

    // Helper method to write content to test file
    private void writeTestFile(String content) throws Exception {

    int writeString(final String str, final byte[] dst, int dstIndex, final boolean useUnicode) {
        final int start = dstIndex;

        try {
            if (useUnicode) {
                // Unicode requires word alignment
                if ((dstIndex - headerStart) % 2 != 0) {
                    dst[dstIndex++] = (byte) '\0';
                }

    }

    @Test
    public void test_longQuery() throws Exception {
        StringBuilder longQuery = new StringBuilder();
        for (int i = 0; i < 100; i++) {
            longQuery.append("word").append(i).append(" ");
        }
        String query = longQuery.toString().trim();

        QueryLog queryLog = new QueryLog(query, null);

        assertEquals(query, queryLog.getQueryString());
    }

</p>

<p>
Reads of memory locations larger than a single machine word
are encouraged but not required to meet the same semantics
as word-sized memory locations,
observing a single allowed write <i>w</i>.
For performance reasons,
implementations may instead treat larger operations
as a set of individual machine-word-sized operations
in an unspecified order.
This means that races on multiword data structures

		the end of the term you are searching.
		<pre>Fess^100</pre>
	</dd>
	<dt>Fuzzy</dt>
	<dd>
		To do a fuzzy search use the "~" symbol at the end of a single word
		term. For example to search for a term similar in spelling to "Fess"
		use the fuzzy search:
		<pre>Fess~0.5</pre>
	</dd>

        SuggestItem item2 = new SuggestItem(text2, readings2, null, 0L, 0L, 1.0f, null, null, null, SuggestItem.Kind.QUERY);

        // Different word order should produce different IDs (since text is "word1 word2" vs "word2 word1")
        assertFalse("Different word order should produce different IDs", item1.getId().equals(item2.getId()));
    }

     */
    public static CrawlingInfoHelper getCrawlingInfoHelper() {
        return getComponent(CRAWLING_INFO_HELPER);
    }

    /**
     * Gets the popular word helper component.
     * @return The popular word helper.
     */
    public static PopularWordHelper getPopularWordHelper() {
        return getComponent(POPULAR_WORD_HELPER);
    }

    /**