gt:     Object[][] ParseData() {
context: /*
   * Copyright (c) 2019, 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.
   */
  
  /*
   * @test
   * @bug 4406815 8222969
   * @summary RuleBasedCollatorTest uses very limited but selected test data
   *  to test basic functionalities provided by RuleBasedCollator.
   * @run testng/othervm RuleBasedCollatorTest
   */
  
  import java.text.CollationElementIterator;
  import java.text.CollationKey;
  import java.text.RuleBasedCollator;
  import java.text.Collator;
  import java.text.ParseException;
  import java.util.Arrays;
  import java.util.Locale;
  
  import org.testng.annotations.BeforeGroups;
  import org.testng.annotations.DataProvider;
  import org.testng.annotations.Test;
  import org.testng.SkipException;
  import static org.testng.Assert.*;
  
  public class RuleBasedCollatorTest {
  
      static RuleBasedCollator USC;
      static String US_RULES;
  
      @BeforeGroups("USC")
      public void setup() {
          Collator c = Collator.getInstance(Locale.US);
          if (!(c instanceof RuleBasedCollator)) {
              throw new SkipException("skip tests.");
          }
          USC = (RuleBasedCollator) c;
          US_RULES = USC.getRules();
      }
  
  
      @DataProvider(name = "rulesData")
      Object[][] rulesData() {
          //Basic Tailor
          String BASIC_TAILOR_RULES = "< b=c<\u00e6;A,a";
          String[] BASIC_TAILOR_DATA = {"\u00e6", "b", "a", "c", "A"};
          String[] BASIC_TAILOR_EXPECTED = {"b", "c", "\u00e6", "A", "a"};
  
          //Contraction
          String CONTRACTION_RULES = US_RULES + "& b < ch ,cH, Ch, CH < c ";
          String[] CONTRACTION_DATA = {"b", "c", "ch", "CH", "Ch", "cH"};
          String[] CONTRACTION_EXPECTED = {"b", "ch", "cH", "Ch", "CH", "c"};
  
          //Expansion
          String EXPANSION_RULES = US_RULES + "& ae = \u00e4 < b";
          String[] EXPANSION_DATA = {"ad", "af", "\u00e4"};
          String[] EXPANSION_EXPECTED = {"ad", "\u00e4", "af"};
  
          //Punctuation
          String PUNCTUATION_RULES = US_RULES + "< ' ' < '-'";
          String[] PUNCTUATION_DATA = {"b-w", "b-W", "B-w", "B-W", "bW", "bw",
                  "Bw", "BW", "b w", "b W", "B w", "B W"};
          String[] PUNCTUATION_EXPECTED = {"bw", "bW", "Bw", "BW", "b w", "b W",
                  "B w", "B W", "b-w", "b-W", "B-w", "B-W"};
  
          return new Object[][] {
                  {BASIC_TAILOR_RULES, BASIC_TAILOR_DATA, BASIC_TAILOR_EXPECTED},
                  {CONTRACTION_RULES, CONTRACTION_DATA, CONTRACTION_EXPECTED},
                  {EXPANSION_RULES, EXPANSION_DATA, EXPANSION_EXPECTED},
                  {PUNCTUATION_RULES, PUNCTUATION_DATA, PUNCTUATION_EXPECTED}
          };
      }
  
      @Test(dataProvider = "rulesData", groups = "USC")
      public void testRules(String rules, String[] testData, String[] expected)
              throws ParseException {
          Arrays.sort(testData, new RuleBasedCollator(rules));
          assertEquals(testData, expected);
  
      }
  
      @DataProvider(name = "FrenchSecondarySort")
      Object[][] FrenchSecondarySort() {
          return new Object[][] {
                  { "\u0061\u00e1\u0061", "\u00e1\u0061\u0061", 1 },
                  //{"\u0061\u00e1", "\u00e1\u0041", 1},  //JDK-4406815
                  //{"\u00e1\u0041", "\u0061\u00e1", -1}, //JDK-4406815
                  {"\u1ea0a", "\u1ea2A", -1}, //case ignore
                  { "\u1ea0b", "\u1ea2A", 1 },  //primary overwrite
                  { "\u1e15", "\u1e1d", -1 },   //ignore sec diacritic
                  { "a", "\u1ea1", -1 } };
      }
  
      @Test(dataProvider = "FrenchSecondarySort", groups = "USC")
      public void testFrenchSecondarySort(String sData, String tData,
              int expected) throws ParseException {
          String french_rule = "@";
          String rules = US_RULES + french_rule;
          RuleBasedCollator rc = new RuleBasedCollator(rules);
          int result = rc.compare(sData, tData);
          assertEquals(expected, result);
      }
  
      @DataProvider(name = "ThaiLaoVowelConsonantSwapping")
      Object[][] ThaiLaoVowelConsonantSwapping() {
          return new Object[][] {{"\u0e44\u0e01", "\u0e40\u0e2e", -1},//swap
                  {"\u0e2e\u0e40", "\u0e01\u0e44", 1},//no swap
                  {"\u0e44\u0061", "\u0e40\u0081", 1}//no swap
          };
      }
  
      @Test(dataProvider = "ThaiLaoVowelConsonantSwapping", groups = "USC")
      public void testThaiLaoVowelConsonantSwapping(String sData, String tData,
              int expected) throws ParseException {
          String thai_rule = "& Z < \u0e01 < \u0e2e <\u0e40 < \u0e44!";
          String rules = US_RULES + thai_rule;
          RuleBasedCollator rc = new RuleBasedCollator(rules);
          int result = rc.compare(sData, tData);
          assertEquals(expected, result);
      }
  
      @Test
      public void testIgnorableCharacter() throws ParseException {
          String rule = "=f<a<c";
          RuleBasedCollator rc = new RuleBasedCollator(rule);
          CollationElementIterator iter = rc.getCollationElementIterator("f");
          int element = iter.next();
          int primary = iter.primaryOrder(element);
          assertEquals(primary, 0);
      }
  
      @DataProvider(name = "Normalization")
      Object[][] Normalization() {
          return new Object[][] {
                  //micro sign has no canonical decomp mapping
                  // 0:NO_Decomposition;
                  // 1:CANONICAL_Decomposition;
                  // 2:FULL_Decomposition
                  {"\u00b5", "\u03BC", 0, -1},
                  {"\u00b5", "\u03BC", 1, -1},
                  {"\u00b5", "\u03BC", 2, 0}
          };
      }
  
      @Test(dataProvider = "Normalization", groups = "USC")
      public void testNormalization(String sData, String tData, int decomp,
              int result) {
          RuleBasedCollator rc = (RuleBasedCollator)USC.clone();
          rc.setDecomposition(decomp);
          assertEquals(rc.compare(sData, tData), result);
      }
  
      @Test
      public void testEquality() throws ParseException {
          String rule1 = "<a=b";
          RuleBasedCollator rc1= new RuleBasedCollator(rule1);
          //test equals()
          assertTrue(rc1.equals(new RuleBasedCollator(rule1)));
  
          //test semantic equality
          String[] array1 = {"b", "c", "a"};
          String[] array2 = Arrays.copyOf(array1, array1.length);
          String[] expected = {"b", "a", "c"};
          String rule2 = "<b=a";
          RuleBasedCollator rc2= new RuleBasedCollator(rule2);
  
          Arrays.sort(array1, rc1);
          Arrays.sort(array2, rc2);
          assertEquals(array1, array2);
          assertEquals(array1, expected);
      }
  
      @Test
      public void testBasicParsingOrder() throws ParseException {
          String rule1 = "< a < b & a < c";
          String rule2 = "< a < c & a < b";
          String rule3 = "< a < b < c";
          String s = "abc";
          RuleBasedCollator c1 = new RuleBasedCollator(rule1);
          RuleBasedCollator c2 = new RuleBasedCollator(rule2);
          RuleBasedCollator c3 = new RuleBasedCollator(rule3);
          CollationKey k1 = c1.getCollationKey(s);
          CollationKey k2 = c2.getCollationKey(s);
          CollationKey k3 = c3.getCollationKey(s);
          //rule1 should not equals to rule2
          assertEquals(k1.compareTo(k2) == 0, false);
  
          //rule2 should equals to rule3
          assertEquals(k2.compareTo(k3) == 0, true);
      }
  
      @DataProvider(name = "ParseData")
  