<error-code>403</error-code>
    <location>/WEB-INF/view/error/redirect.jsp?type=logOut</location>
  </error-page>
  <error-page>
    <error-code>404</error-code>
    <location>/WEB-INF/view/error/redirect.jsp?type=notFound</location>
  </error-page>
  <error-page>
    <error-code>408</error-code>
    <location>/WEB-INF/view/error/redirect.jsp?type=logOut</location>
  </error-page>
  <error-page>
    <error-code>500</error-code>

		lastHandout:  metaCacheTestsetTimestamp,
		dataVersion:  metacacheStreamVersion,
	},
	5: {
		id:           "case-6-404notfound",
		bucket:       "bucket",
		root:         "folder/notfound",
		recursive:    true,
		status:       scanStateSuccess,
		fileNotFound: true,
		error:        "",
		started:      metaCacheTestsetTimestamp,
		ended:        metaCacheTestsetTimestamp.Add(time.Minute),

		<postConstruct name="addDesignJspFileName">
			<arg>"error"</arg>
			<arg>"error/error.jsp"</arg>
		</postConstruct>
		<postConstruct name="addDesignJspFileName">
			<arg>"errorNotFound"</arg>
			<arg>"error/notFound.jsp"</arg>
		</postConstruct>
		<postConstruct name="addDesignJspFileName">
			<arg>"errorSystem"</arg>
			<arg>"error/system.jsp"</arg>
		</postConstruct>
		<postConstruct name="addDesignJspFileName">

		fallthrough
	case "forbidden":
		err = PrefixAccessDenied{
			Bucket: bucket,
			Object: object,
		}
	case "invalid":
		err = BucketNameInvalid{
			Bucket: bucket,
		}
	case "notFound":
		if object != "" {
			err = ObjectNotFound{
				Bucket: bucket,
				Object: object,
			}
			break
		}
		err = BucketNotFound{Bucket: bucket}
	case "conflict":

    /** The path of the HTML: /error/error.jsp */
    HtmlNext path_Error_ErrorJsp = new HtmlNext("/error/error.jsp");

    /** The path of the HTML: /error/notFound.jsp */
    HtmlNext path_Error_NotFoundJsp = new HtmlNext("/error/notFound.jsp");

    /** The path of the HTML: /error/redirect.jsp */
    HtmlNext path_Error_RedirectJsp = new HtmlNext("/error/redirect.jsp");

// If no files were found false will be returned.
func isObjectDirDangling(errs []error) (ok bool) {
	var found int
	var notFound int
	var foundNotEmpty int
	var otherFound int
	for _, readErr := range errs {
		switch readErr {
		case nil:
			found++
		case errFileNotFound, errVolumeNotFound:
			notFound++
		case errVolumeNotEmpty:
			foundNotEmpty++
		default:
			otherFound++
		}
	}

        assertEquals("/error/badRequest.jsp", FessHtmlPath.path_Error_BadRequestJsp.getRoutingPath());
        assertEquals("/error/error.jsp", FessHtmlPath.path_Error_ErrorJsp.getRoutingPath());
        assertEquals("/error/notFound.jsp", FessHtmlPath.path_Error_NotFoundJsp.getRoutingPath());
        assertEquals("/error/redirect.jsp", FessHtmlPath.path_Error_RedirectJsp.getRoutingPath());

		Scopes:      scopes,
	}

	state := randomState()

	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		log.Printf("%s %s", r.Method, r.RequestURI)
		if r.RequestURI != "/" {
			http.NotFound(w, r)
			return
		}
		if clientSec != "" {
			http.Redirect(w, r, config.AuthCodeURL(state), http.StatusFound)
		} else {
			http.Redirect(w, r, implicitFlowURL(config, state), http.StatusFound)
		}
	})

    return nullptr;
  }

  const tensorflow::OpDef_ArgDef& input_arg = op_def->input_arg()[input_index];

  if (input_arg.number_attr().empty()) {
    status->status = tensorflow::errors::NotFound(
        op_name, " does not have number_attr() defined.");
    return nullptr;
  }

  // The returned string is owned by OpRegistry, so liveness is not a concern.
  return input_arg.number_attr().c_str();
}

      200,
      "Body",
      ProtocolException::class.java,
      "Expected HTTP 101 response but was '200 OK'",
    )
  }

  @Test
  @Throws(IOException::class)
  fun notFound() {
    webServer.enqueue(
      MockResponse
        .Builder()
        .status("HTTP/1.1 404 Not Found")
        .build(),
    )
    newWebSocket()
    clientListener.assertFailure(
      404,