bridge.valve.start()
        bridge.register(listener)
        bridge.register(listener)

        then:
        thrown IllegalStateException
    }

    def "can register again after resetting valve"() {
        when:
        def bridge = getOrCreateBridge()
        bridge.valve.start()
        bridge.register(listener)
        bridge.valve.stop()
        bridge.valve.start()

        }
    }

    private State state;

    private final BuildOperationNotificationValve valve = new BuildOperationNotificationValve() {
        @Override
        public void start() {
            if (state != null) {
                throw new IllegalStateException("build operation notification valve already started");
            }

            state = new State();

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.tomcat.valve;

import org.apache.catalina.valves.ErrorReportValve;

public class SuppressErrorReportValve extends ErrorReportValve {
    public SuppressErrorReportValve() {
        setShowReport(false);
        setShowServerInfo(false);
    }

        final String value = System.getProperty(FESS_PORT);
        if (value != null) {
            return Integer.parseInt(value);
        }
        return 8080;
    }

    protected static String getContextPath() {
        final String value = System.getProperty(FESS_CONTEXT_PATH);
        if (value != null && !"/".equals(value)) {
            return value;
        }
        return StringUtil.EMPTY;

// StringValue returns a new [Value] for a string.
func StringValue(value string) Value {
	return Value{num: uint64(len(value)), any: stringptr(unsafe.StringData(value))}
}

// IntValue returns a [Value] for an int.
func IntValue(v int) Value {
	return Int64Value(int64(v))
}

// Int64Value returns a [Value] for an int64.
func Int64Value(v int64) Value {
	return Value{num: uint64(v), any: KindInt64}
}

func ValueOf(i any) Value {
	if i == nil {
		return Value{}
	}
	return unpackEface(i)
}

// assignTo returns a value v that can be assigned directly to typ.
// It panics if v is not assignable to typ.
// For a conversion to an interface type, target is a suggested scratch space to use.
func (v Value) assignTo(context string, dst *abi.Type, target unsafe.Pointer) Value {
	// if v.flag&flagMethod != 0 {

func FromTimestamp(t time.Time) *Value {
	return &Value{value: t}
}

// FromNull creates a Value with Null value
func FromNull() *Value {
	return &Value{value: nil}
}

// FromMissing creates a Value with Missing value
func FromMissing() *Value {
	return &Value{value: Missing{}}
}

// FromBytes creates a Value from a []byte
func FromBytes(b []byte) *Value {
	return &Value{value: b}
}

package atomic

import (
	"unsafe"
)

// A Value provides an atomic load and store of a consistently typed value.
// The zero value for a Value returns nil from [Value.Load].
// Once [Value.Store] has been called, a Value must not be copied.
//
// A Value must not be copied after first use.
type Value struct {
	v any
}

// efaceWords is interface{} internal representation.

func (dv *DynValue) ExprValue() ref.Val {
	return dv.exprValue
}

// Value returns the underlying value held by this reference.
func (dv *DynValue) Value() interface{} {
	return dv.value
}

// SetValue updates the underlying value held by this reference.
func (dv *DynValue) SetValue(value interface{}) error {
	dv.value = value
	var err error

      // initialized value.
      type_ = NONE;
    }
  }
  ~TaggedValue() { destroy(); }

  /// @brief Get the underlying value based on type.
  ///
  /// @tparam T The desired return type.
  /// @return The unwrapped value. If this `TaggedValue` type does not currently
  ///         contain a value of type `T`, the program terminates via a call to
  ///         `assert`.