<label for="regex" class="col-sm-3 text-sm-right col-form-label"><la:message
                                            key="labels.regex"/></label>
                                    <div class="col-sm-9">
                                        <la:errors property="regex"/>
                                        <la:text styleId="regex" property="regex" styleClass="form-control"/>

  //
  // It should look like:
  //
  // specs {matcher {function_name {regex: ".*"}} method {static_range_ptq {}}}
  // specs {
  //   matcher {function_name {regex: "composite_conv.*"}}
  //   method {static_range_ptq {...}}}
  // }
  // specs {
  //   matcher {function_name {regex: "composite_dot_general_fn_1"}}
  //   method {no_quantization {}}
  // }

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.rule.impl;

import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.codelibs.core.beans.util.BeanUtil;
import org.codelibs.core.beans.util.CopyOptions;
import org.codelibs.fess.crawler.entity.ResponseData;

/**
 * @author shinsuke
 *
 */

                    principalName:
                      safeRegex:
                        regex: .+
        - andIds:
            ids:
            - orIds:
                ids:
                - authenticated:
                    principalName:
                      safeRegex:
                        regex: spiffe://.*/ns/foo/sa/rule[0]-from[1]-principal[0]
                - authenticated:

func.func @import_stats_name_regex(%arg0: tensor<4xf32>, %cst: tensor<i32>) -> (tensor<2xf32>,tensor<2xf32>) {
  %0:2 = "tfl.split"(%cst, %arg0) {num_splits = 2 : i32, name = "op_regex"} : (tensor<i32>, tensor<4xf32>) -> (tensor<2xf32>, tensor<2xf32>)
    loc(fused["skip1.cc":10:8, "op_regex", callsite("skip2" at "skip3.cc":10:8)])
  func.return %0#0, %0#1 : tensor<2xf32>, tensor<2xf32>

// CHECK-NEXT: %[[split:.*]]:2 = "tfl.split"

                - authenticated:
                    principalName:
                      safeRegex:
                        regex: .*/ns/rule[0]-from[0]-ns[1]/.*
                - authenticated:
                    principalName:
                      safeRegex:
                        regex: .*/ns/rule[0]-from[0]-ns[2]/.*
            - orIds:
                ids:
                - remoteIp:

		},
		{
			name:        "dns1123Subdomain",
			expr:        `format.dns1123Subdomain().validate("contains a space")`,

         <trusted-key id="B000000000000000000000000000000000000000">
            <trusting name="m3" version="1.4" file="file.zip"/>
            <trusting name="m4" file="other-file.zip" regex="true"/>
         </trusted-key>
         <trusted-key id="C000000000000000000000000000000000000000" group="g3" name="m2" version="1.0" regex="true"/>

            if (entity.getTerm().startsWith(regexPrefix)) {
                final String regex = entity.getTerm().substring(regexPrefix.length());
                if (StringUtil.isBlank(regex)) {
                    logger.warn("Unknown regex pattern: {}", entity.getTerm());
                } else {
                    pair.getSecond().add(new Pair<>(Pattern.compile(regex), entity.getContent()));
                }
            } else {

        buildFile.toString()
    }

    static void assertSingleGenerationOutput(String output, String regex) {
        def pattern = /\b${regex}\b/
        def matcher = output =~ pattern
        assert matcher.count == 1
    }

    static void assertNoGenerationOutput(String output, String regex) {
        def pattern = /\b${regex}\b/
        def matcher = output =~ pattern
        assert matcher.count == 0
    }