* 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
    }

                    principalName:
                      safeRegex:
                        regex: .*/ns/ns/.*
            - notId:
                orIds:
                  ids:
                  - authenticated:
                      principalName:
                        safeRegex:
                          regex: .*/ns/not-ns/.*
            - orIds:
                ids:
                - remoteIp:

  hosts:
  - a.domain.example
  http:
  - match:
    - headers:
        my-header:
          exact: some-value
      queryParams:
        my-param:
          regex: some-value
      uri:
        exact: /baz
    name: allowed-2.http.1
    route:
    - destination:
        host: svc2.allowed-2.svc.domain.suffix
        port:
          number: 80
  - match:
    - uri: