@Override public CharSequence subSequence(int start, int end) { return new StringValue(this, start, end - start); }
@Override public StringValue createInstance() { return new StringValue(); }
@Override public CharSequence subSequence(int start, int end) { return new StringValue(this, start, end - start); }
@Override public StringValue createValue() { return new StringValue(); }
/** * Returns a new <tt>StringValue</tt>string that is a substring of this string. The * substring begins at the given <code>start</code> index and ends at <code>end - 1</code>. * * @param start The beginning index, inclusive. * @param end The ending index, exclusive. * @return The substring. * @exception IndexOutOfBoundsException * Thrown, if the start is negative, or the end is larger than the length. */ public StringValue substring(int start, int end) { return new StringValue(this, start, end - start); }
@Override public StringValue[] getValidTestResults() { return new StringValue[] { new StringValue("abcdefgh"), new StringValue("i"), new StringValue("jklmno"), new StringValue("abcdefgh"), new StringValue("i"), new StringValue("jklmno"), new StringValue("ab,cde|fg"), new StringValue("hij|m|n|op"), new StringValue("abcdefgh"), new StringValue("i"), new StringValue("jklmno"), new StringValue(" abcd ") }; }
public StringIntPair(String first, int second) { super(new StringValue(first), new IntValue(second)); } }
/** * Returns the record to write at the given position */ protected Record getRecord(int index) { return new Record(new IntValue(index), new StringValue(String.valueOf(index))); }
@Test public void testToLowerCaseConverting() { StringValue testString = new StringValue("TEST"); SimpleStringUtils.toLowerCase(testString); assertEquals(new StringValue("test"), testString); }
@Override public void reduce(Iterator<Record> it, Collector<Record> out) { // Compute the sum int sum = 0; while (it.hasNext()) { sum += Integer.parseInt(it.next().getField(0, StringValue.class).getValue()) + 1; } out.collect(new Record(new StringValue(Integer.toString(sum)))); } }
@Override public void reduce(Iterator<Record> it, Collector<Record> out) { // Compute the sum int sum = 0; while (it.hasNext()) { sum += Integer.parseInt(it.next().getField(0, StringValue.class).getValue()) + 1; } out.collect(new Record(new StringValue(Integer.toString(sum)))); } }
@Test public void testReplaceNonWordChars() { StringValue testString = new StringValue("TEST123_@"); SimpleStringUtils.replaceNonWordChars(testString, '!'); assertEquals(new StringValue("TEST123_!"), testString); }
@Override public void reduce(Iterator<Record> records, Collector<Record> out) throws Exception { Record r = records.next(); int num = r.getField(1, IntValue.class).getValue(); String names = r.getField(0, SUser.class).datum().getFavoriteColor().toString(); while (records.hasNext()) { r = records.next(); names += " - " + r.getField(0, SUser.class).datum().getFavoriteColor().toString(); } result.setField(0, new IntValue(num)); result.setField(1, new StringValue(names)); out.collect(result); }
@Override public void reduce(Iterator<Record> it, Collector<Record> out) { // Compute the sum int sum = 0; while (it.hasNext()) { Integer value = Integer.parseInt(it.next().getField(0, StringValue.class).getValue()); sum += value; testCounter.add(value); } out.collect(new Record(new StringValue(Integer.toString(sum)))); } }
@Override public void map(Record record, Collector<Record> collector) { String line = record.getField(0, StringValue.class).getValue(); String [] element = line.split(" "); String word = element[0]; int count = Integer.parseInt(element[1]); if (stringList.contains(word)) { collector.collect(new Record(new StringValue(word), new IntValue(count))); } } }
@Test public void testParseInvalidQuotedStrings() { // check valid strings with out whitespaces and trailing delimiter byte[] recBytes = " \"abcdefgh\" gh | \"i\"\t\t\t|\t \t\"jklmno\" |".getBytes(); StringValue s = new StringValue(); int startPos = 0; startPos = parser.parseField(recBytes, startPos, recBytes.length, '|', s); assertTrue(startPos < 0); } }
@Override public void join(Record order, Record line, Collector<Record> out) throws Exception { Tuple orderTuple = order.getField(1, Tuple.class); orderTuple.project(32); String newOrderKey = orderTuple.getStringValueAt(0); order.setField(0, new StringValue(newOrderKey)); out.collect(order); } }
@Test public void testTokenizerOnStringWithNexToken() { StringValue testString = new StringValue("test test"); SimpleStringUtils.WhitespaceTokenizer tokenizer = new WhitespaceTokenizer(); tokenizer.setStringToTokenize(testString); assertTrue(tokenizer.next(testString)); }
@Test public void testTokenizerOnStringOnlyWithDelimiter() { StringValue testString = new StringValue(" "); SimpleStringUtils.WhitespaceTokenizer tokenizer = new WhitespaceTokenizer(); tokenizer.setStringToTokenize(testString); assertFalse(tokenizer.next(testString)); } }
@Test public void testTokenizerOnStringWithoutNexToken() { StringValue testString = new StringValue("test"); SimpleStringUtils.WhitespaceTokenizer tokenizer = new WhitespaceTokenizer(); tokenizer.setStringToTokenize(testString); //first token tokenizer.next(testString); //next token is not exist assertFalse(tokenizer.next(testString)); }