this.longMessage = longMessage;
    }

    /**
     * Constructs a new {@code MojoException} wrapping an underlying {@code Throwable}
     * and providing a {@code message}.
     */
    public MojoException(String message, Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new {@code MojoException} providing a {@code message}.
     */

package crc32

import "internal/byteorder"

// simpleMakeTable allocates and constructs a Table for the specified
// polynomial. The table is suitable for use with the simple algorithm
// (simpleUpdate).
func simpleMakeTable(poly uint32) *Table {
	t := new(Table)
	simplePopulateTable(poly, t)
	return t
}

// simplePopulateTable constructs a Table for the specified polynomial, suitable
// for use with simpleUpdate.

  /// TaggedValue constructor for type FLOAT32.
  explicit TaggedValue(float f32) : type_(FLOAT32), data_(Float32(f32)) {}
  /// TaggedValue constructor for type INT64.
  explicit TaggedValue(int64_t i64) : type_(INT64), data_(Int64(i64)) {}
  /// TaggedValue constructor for type FLOAT32.
  explicit TaggedValue(Float32 f32) : type_(FLOAT32), data_(f32) {}
  /// TaggedValue constructor for type INT64.

const Version = "1"

// NewEntry - constructs an audit entry object with some fields filled
func NewEntry(deploymentID string) audit.Entry {
	return audit.Entry{
		Version:      Version,
		DeploymentID: deploymentID,
		Time:         time.Now().UTC(),
	}
}

// ToEntry - constructs an audit entry from a http request

template <typename T>
class ConstructScalarTensorTest : public ::testing::Test {};
TYPED_TEST_SUITE(ConstructScalarTensorTest, SimpleTypes);

// This test constructs a scalar tensor for each of the types in "SimpleTypes",
// and verifies the expected dimensions, dtype, value, number of bytes, and
// number of elements.

	blockTypeECPrivateKey    = "EC PRIVATE KEY"
	blockTypeRSAPrivateKey   = "RSA PRIVATE KEY" // PKCS#1 private key
	blockTypePKCS8PrivateKey = "PRIVATE KEY"     // PKCS#8 plain private key
)

// ParsePemEncodedCertificate constructs a `x509.Certificate` object using the
// given a PEM-encoded certificate.
func ParsePemEncodedCertificate(certBytes []byte) (*x509.Certificate, error) {
	cb, _ := pem.Decode(certBytes)
	if cb == nil {

template <typename T>
class ConstructScalarTensorHandleTest : public ::testing::Test {};
TYPED_TEST_SUITE(ConstructScalarTensorHandleTest, SimpleTypes);

// This test constructs a scalar tensor for each of the types in "SimpleTypes",
// then wraps it in a TensorHandle. We then unwrap it back into a Tensor, and
// verify the expected dims, dtype, value, num bytes, and num elements.

type PluginInitializer struct {
	cloudConfig []byte
}

var _ admission.PluginInitializer = &PluginInitializer{}

// NewPluginInitializer constructs new instance of PluginInitializer
func NewPluginInitializer(cloudConfig []byte) *PluginInitializer {
	return &PluginInitializer{
		cloudConfig: cloudConfig,
	}
}

// with apply.
type ContainerUserApplyConfiguration struct {
	Linux *LinuxContainerUserApplyConfiguration `json:"linux,omitempty"`
}

// ContainerUserApplyConfiguration constructs an declarative configuration of the ContainerUser type for use with
// apply.
func ContainerUser() *ContainerUserApplyConfiguration {
	return &ContainerUserApplyConfiguration{}
}

type PluginInitializer struct {
	quotaConfiguration         quota.Configuration
	excludedAdmissionResources []schema.GroupResource
}

var _ admission.PluginInitializer = &PluginInitializer{}

// NewPluginInitializer constructs new instance of PluginInitializer
func NewPluginInitializer(
	quotaConfiguration quota.Configuration,
	excludedAdmissionResources []schema.GroupResource,
) *PluginInitializer {
	return &PluginInitializer{