undefect. CWE-407 — 63 sites patched across 27 ecosystems

Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com

Patches, unit tests, benchmarks, whitepaper, and outreach briefs.
Public domain — no copyright claimed. Use freely.

test/jdk/java/util/Scanner/ScannerStreamTest.java

@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.regex.Matcher;
+import java.util.regex.MatchResult;
+import java.util.regex.Pattern;
+import java.util.stream.LambdaTestHelpers;
+import java.util.stream.OpTestCase;
+import java.util.stream.Stream;
+import java.util.stream.TestData;
+
+import static org.testng.Assert.*;
+
+/**
+ * @test
+ * @bug 8072722 8150488
+ * @summary Tests of stream support in java.util.Scanner
+ * @library /lib/testlibrary/bootlib
+ * @build java.base/java.util.stream.OpTestCase
+ * @run testng/othervm ScannerStreamTest
+ */
+
+@Test
+public class ScannerStreamTest extends OpTestCase {
+
+    static File inputFile = new File(System.getProperty("test.src", "."), "input.txt");
+
+    @DataProvider(name = "Tokens")
+    public static Object[][] makeTokensTestData() {
+        // each inner array is [String description, String input, String delimiter]
+        // delimiter may be null
+        List<Object[]> data = new ArrayList<>();
+
+        data.add(new Object[] { "default delimiter", "abc def ghi",           null });
+        data.add(new Object[] { "fixed delimiter",   "abc,def,,ghi",          "," });
+        data.add(new Object[] { "regex delimiter",   "###abc##def###ghi###j", "#+" });
+
+        return data.toArray(new Object[0][]);
+    }
+
+    /*
+     * Creates a scanner over the input, applying a delimiter if non-null.
+     */
+    Scanner makeScanner(String input, String delimiter) {
+        Scanner sc = new Scanner(input);
+        if (delimiter != null) {
+            sc.useDelimiter(delimiter);
+        }
+        return sc;
+    }
+
+    /*
+     * Given input and a delimiter, tests that tokens() returns the same
+     * results that would be provided by a Scanner hasNext/next loop.
+     */
+    @Test(dataProvider = "Tokens")
+    public void tokensTest(String description, String input, String delimiter) {
+        // derive expected result by using conventional loop
+        Scanner sc = makeScanner(input, delimiter);
+        List<String> expected = new ArrayList<>();
+        while (sc.hasNext()) {
+            expected.add(sc.next());
+        }
+
+        Supplier<Stream<String>> ss = () -> makeScanner(input, delimiter).tokens();
+        withData(TestData.Factory.ofSupplier(description, ss))
+                .stream(LambdaTestHelpers.identity())
+                .expectedResult(expected)
+                .exercise();
+    }
+
+    /*
+     * Creates a Scanner over the given input file.
+     */
+    Scanner makeFileScanner(File file) {
+        try {
+            return new Scanner(file, "UTF-8");
+        } catch (IOException ioe) {
+            throw new UncheckedIOException(ioe);
+        }
+    }
+
+    /*
+     * Tests that the matches produced by findAll(pat) are the same
+     * as what are returned by findWithinHorizon(pat, 0). This tests
+     * a single pattern against a single input file.
+     */
+    public void findAllFileTest() {
+        // derive expected result by using conventional loop
+        Pattern pat = Pattern.compile("[A-Z]{7,}");
+        List<String> expected = new ArrayList<>();
+
+        try (Scanner sc = makeFileScanner(inputFile)) {
+            String match;
+            while ((match = sc.findWithinHorizon(pat, 0)) != null) {
+                expected.add(match);
+            }
+        }
+
+        Supplier<Stream<String>> ss =
+            () -> makeFileScanner(inputFile).findAll(pat).map(MatchResult::group);
+
+        withData(TestData.Factory.ofSupplier("findAllFileTest", ss))
+                .stream(LambdaTestHelpers.identity())
+                .expectedResult(expected)
+                .exercise();
+    }
+
+    @DataProvider(name = "FindAllZero")
+    public static Object[][] makeFindAllZeroTestData() {
+        // each inner array is [String input, String patternString]
+        List<Object[]> data = new ArrayList<>();
+
+        data.add(new Object[] { "aaaaa",        "a*" });
+        data.add(new Object[] { "aaaaab",       "a*" });
+        data.add(new Object[] { "aaaaabb",      "a*" });
+        data.add(new Object[] { "aaaaabbb",     "a*" });
+        data.add(new Object[] { "aaabbaaaa",    "a*" });
+        data.add(new Object[] { "aaabbaaaab",   "a*" });
+        data.add(new Object[] { "aaabbaaaabb",  "a*" });
+        data.add(new Object[] { "aaabbaaaabbb", "a*" });
+        data.add(new Object[] { "aaabbaaaa",    "a*|b*" });
+        data.add(new Object[] { "aaabbaaaab",   "a*|b*" });
+        data.add(new Object[] { "aaabbaaaabb",  "a*|b*" });
+        data.add(new Object[] { "aaabbaaaabbb", "a*|b*" });
+
+        return data.toArray(new Object[0][]);
+    }
+
+    /*
+     * Tests findAll() using a pattern against an input string.
+     * The results from findAll() should equal the results obtained
+     * using a loop around Matcher.find().
+     *
+     * The provided regexes should allow zero-length matches.
+     * This primarily tests the auto-advance feature of findAll() that
+     * occurs if the regex match is of zero length to see if it has the
+     * same behavior as Matcher.find()'s auto-advance (JDK-8150488).
+     * Without auto-advance, findAll() would return an infinite stream
+     * of zero-length matches. Apply a limit to the stream so
+     * that an infinite stream will be truncated. The limit must be
+     * high enough that the resulting truncated stream won't be
+     * mistaken for a correct expected result.
+     */
+    @Test(dataProvider = "FindAllZero")
+    public void findAllZeroTest(String input, String patternString) {
+        Pattern pattern = Pattern.compile(patternString);
+
+        // generate expected result using Matcher.find()
+        Matcher m = pattern.matcher(input);
+        List<String> expected = new ArrayList<>();
+        while (m.find()) {
+            expected.add(m.group());
+        }
+
+        Supplier<Stream<String>> ss = () -> new Scanner(input).findAll(pattern)
+                                                              .limit(100)
+                                                              .map(MatchResult::group);
+
+        withData(TestData.Factory.ofSupplier("findAllZeroTest", ss))
+                .stream(LambdaTestHelpers.identity())
+                .expectedResult(expected)
+                .exercise();
+    }
+}