<stringParams>
                <stringParam>one</stringParam>
                <stringParam>two</stringParam>
                <stringParam>three</stringParam>
                <stringParam>four</stringParam>
              </stringParams>
              <propertiesParam>
                <property>
                  <name>key1</name>
                  <value>value1</value>
                </property>

    RowSortedTable<String, Character, Integer> table = TreeBasedTable.create();
    table.put("one", 'a', 1);
    table.put("two", 'a', 2);
    table.put("three", 'a', 3);
    table.put("four", 'b', 4);
    return Tables.unmodifiableRowSortedTable(table).column('a');
  }

    Table<String, Character, Integer> table = HashBasedTable.create();
    table.put("one", 'a', 1);
    table.put("two", 'a', 2);
    table.put("three", 'a', 3);
    table.put("four", 'b', 4);
    return Tables.unmodifiableTable(table).column('a');
  }

              <stringParams>
                <stringParam>one</stringParam>
                <stringParam>two</stringParam>
                <stringParam>three</stringParam>
                <stringParam>four</stringParam>
              </stringParams>
              <propertiesParam>
                <property>
                  <name>key1</name>
                  <value>value1</value>
                </property>

	"image/color.YCbCr":   true,
	"image.Point":         true,
	"image.Rectangle":     true,
	"image.Uniform":       true,

	"unicode.Range16": true,
	"unicode.Range32": true,

	// These four structs are used in generated test main files,
	// but the generator can be trusted.
	"testing.InternalBenchmark":  true,
	"testing.InternalExample":    true,
	"testing.InternalTest":       true,

// position 0, 1, 2, and 3 respectively, and an increasing counter
// starting at zero is subtracted from each word at position 12. Then,
// this stream is permuted such that for each sequence of four blocks,
// first we output the first four bytes of each block, then the next four
// bytes of each block, and so on. Finally, the last 32 bytes of output
// are used as the input of the next iteration, and the remaining 992
// bytes are the RNG output.
//

    Table<Character, String, Integer> table = HashBasedTable.create();
    table.put('a', "one", 2);
    table.put('a', "two", 4);
    table.put('a', "three", 6);
    table.put('b', "four", 8);
    return Tables.transformValues(table, TableCollectionTest.DIVIDE_BY_2).row('a');
  }

    throw new UnsupportedOperationException();
  }

  @Override
  Table<String, Character, Integer> makeTable() {
    return ArrayTable.create(
        Arrays.asList("one", "two", "three", "four"), Arrays.asList('a', 'b', 'c'));
  }

  }

  @Override
  protected Table<Character, String, Integer> makeTable() {
    return ArrayTable.create(
        Arrays.asList('a', 'b', 'c'), Arrays.asList("one", "two", "three", "four"));
  }

// See the License for the specific language governing permissions and
// limitations under the License.

package trustdomain

import "strings"

// stringMatch checks if a string is in a list, it supports four types of string matches:
// 1. Exact match.
// 2. Wild character match. "*" matches any string.
// 3. Prefix match. For example, "book*" matches "bookstore", "bookshop", etc.