test_support.c File Reference

C test module for PICurv. More...

#include "test_support.h"
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

Include dependency graph for test_support.c:

Go to the source code of this file.

Functions
static PetscErrorCode	DestroyVecIfSet (Vec *vec)
	Test-local routine.
static PetscErrorCode	DestroyDMIfSet (DM *dm)
	Test-local routine.
static PetscErrorCode	RegisterSwarmFieldForTests (DM swarm, const char *field_name, PetscInt field_dim, PetscDataType dtype)
	Test-local routine.
PetscErrorCode	PicurvRunTests (const char *suite_name, const PicurvTestCase *cases, size_t case_count)
	Shared test-support routine.
PetscErrorCode	PicurvEnsureDir (const char *path)
	Shared test-support routine.
PetscErrorCode	PicurvMakeTempDir (char *path, size_t path_len)
	Shared test-support routine.
PetscErrorCode	PicurvCreateMinimalContexts (SimCtx **simCtx_out, UserCtx **user_out, PetscInt mx, PetscInt my, PetscInt mz)
	Shared test-support routine.
PetscErrorCode	PicurvPopulateIdentityMetrics (UserCtx *user)
	Shared test-support routine.
PetscErrorCode	PicurvCreateSwarmPair (UserCtx *user, PetscInt nlocal, const char *post_field_name)
	Shared test-support routine.
PetscErrorCode	PicurvDestroyMinimalContexts (SimCtx **simCtx_ptr, UserCtx **user_ptr)
	Shared test-support routine.
PetscErrorCode	PicurvAssertRealNear (PetscReal expected, PetscReal actual, PetscReal tol, const char *context)
	Shared test-support routine.
PetscErrorCode	PicurvAssertIntEqual (PetscInt expected, PetscInt actual, const char *context)
	Shared test-support routine.
PetscErrorCode	PicurvAssertBool (PetscBool value, const char *context)
	Shared test-support routine.
PetscErrorCode	PicurvAssertFileExists (const char *path, const char *context)
	Shared test-support routine.
PetscErrorCode	PicurvAssertVecConstant (Vec vec, PetscScalar expected, PetscReal tol, const char *context)
	Shared test-support routine.

Detailed Description

C test module for PICurv.

Definition in file test_support.c.

Function Documentation

DestroyVecIfSet()

static PetscErrorCode DestroyVecIfSet ( Vec *  vec )

static

Test-local routine.

Definition at line 19 of file test_support.c.

{
    PetscFunctionBeginUser;
    if (vec && *vec) {
        PetscCall(VecDestroy(vec));
    }
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

DestroyDMIfSet()

static PetscErrorCode DestroyDMIfSet ( DM *  dm )

static

Test-local routine.

Definition at line 31 of file test_support.c.

{
    PetscFunctionBeginUser;
    if (dm && *dm) {
        PetscCall(DMDestroy(dm));
    }
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

RegisterSwarmFieldForTests()

static PetscErrorCode RegisterSwarmFieldForTests ( DM  swarm, const char *  field_name, PetscInt  field_dim, PetscDataType  dtype  )

static

Test-local routine.

Definition at line 43 of file test_support.c.

{
    PetscFunctionBeginUser;
    PetscCall(DMSwarmRegisterPetscDatatypeField(swarm, field_name, field_dim, dtype));
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

PicurvRunTests()

PetscErrorCode PicurvRunTests	(	const char *	suite_name,
		const PicurvTestCase *	cases,
		size_t	case_count
	)

Shared test-support routine.

Executes a table of unit tests and reports aggregated pass/fail status.

Definition at line 53 of file test_support.c.

{
    PetscFunctionBeginUser;
 
    PetscCall(PetscPrintf(PETSC_COMM_WORLD, "==> Running %s (%zu tests)\n", suite_name, case_count));
    for (size_t i = 0; i < case_count; ++i) {
        PetscCall(PetscPrintf(PETSC_COMM_WORLD, "  -> %s\n", cases[i].name));
        PetscCall(cases[i].fn());
        PetscCall(PetscPrintf(PETSC_COMM_WORLD, "     [PASS] %s\n", cases[i].name));
    }
 
    PetscCall(PetscPrintf(PETSC_COMM_WORLD, "==> %s complete\n", suite_name));
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

PicurvEnsureDir()

PetscErrorCode PicurvEnsureDir

(

const char *

path

)

Shared test-support routine.

Ensures a directory exists, creating it if required.

Definition at line 71 of file test_support.c.

{
    PetscFunctionBeginUser;
    if (mkdir(path, 0777) != 0 && errno != EEXIST) {
        SETERRQ(PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Failed to create directory '%s': %s", path, strerror(errno));
    }
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

PicurvMakeTempDir()

PetscErrorCode PicurvMakeTempDir	(	char *	path,
		size_t	path_len
	)

Shared test-support routine.

Creates a unique temporary directory path and materializes the directory.

Definition at line 83 of file test_support.c.

{
    PetscFunctionBeginUser;
    if (!path || path_len < 24) {
        SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_NULL, "Temp directory buffer is missing or too small.");
    }
 
    PetscCall(PetscSNPrintf(path, path_len, "/tmp/picurv-test-XXXXXX"));
    if (!mkdtemp(path)) {
        SETERRQ(PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "mkdtemp failed for '%s': %s", path, strerror(errno));
    }
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

PicurvCreateMinimalContexts()

PetscErrorCode PicurvCreateMinimalContexts	(	SimCtx **	simCtx_out,
		UserCtx **	user_out,
		PetscInt	mx,
		PetscInt	my,
		PetscInt	mz
	)

Shared test-support routine.

Creates minimal PETSc/solver contexts used by isolated kernel tests.

Definition at line 100 of file test_support.c.

{
    SimCtx *simCtx = NULL;
    UserCtx *user = NULL;
 
    PetscFunctionBeginUser;
    if (!simCtx_out || !user_out) {
        SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_NULL, "Output pointers cannot be NULL.");
    }
 
    PetscCall(PetscCalloc1(1, &simCtx));
    PetscCall(PetscCalloc1(1, &user));
 
    PetscCallMPI(MPI_Comm_rank(PETSC_COMM_WORLD, &simCtx->rank));
    simCtx->block_number = 1;
    simCtx->dt = 0.1;
    simCtx->tiout = 2;
    simCtx->forceScalingFactor = 1.0;
    simCtx->LoggingFrequency = 1;
    simCtx->exec_mode = EXEC_MODE_SOLVER;
    simCtx->mom_solver_type = MOMENTUM_SOLVER_EXPLICIT_RK;
    simCtx->poisson = 0;
    simCtx->ren = 1.0;
    simCtx->schmidt_number = 1.0;
    simCtx->StartStep = 0;
    simCtx->StepsToRun = 1;
    simCtx->step = 1;
    simCtx->np = 0;
    PetscCall(PetscStrncpy(simCtx->euler_subdir, "euler", sizeof(simCtx->euler_subdir)));
    PetscCall(PetscStrncpy(simCtx->particle_subdir, "particles", sizeof(simCtx->particle_subdir)));
    PetscCall(PetscStrncpy(simCtx->output_dir, "/tmp", sizeof(simCtx->output_dir)));
    PetscCall(PetscStrncpy(simCtx->restart_dir, "/tmp", sizeof(simCtx->restart_dir)));
 
    user->simCtx = simCtx;
    user->_this = 0;
    user->IM = mx;
    user->JM = my;
    user->KM = mz;
 
    PetscCall(DMDACreate3d(PETSC_COMM_WORLD,
                           DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE,
                           DMDA_STENCIL_BOX,
                           mx, my, mz,
                           PETSC_DECIDE, PETSC_DECIDE, PETSC_DECIDE,
                           1, 1,
                           NULL, NULL, NULL,
                           &user->da));
    PetscCall(DMSetUp(user->da));
    PetscCall(DMDASetUniformCoordinates(user->da, 0.0, (PetscReal)(mx - 1), 0.0, (PetscReal)(my - 1), 0.0, (PetscReal)(mz - 1)));
 
    PetscCall(DMDACreate3d(PETSC_COMM_WORLD,
                           DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE,
                           DMDA_STENCIL_BOX,
                           mx, my, mz,
                           PETSC_DECIDE, PETSC_DECIDE, PETSC_DECIDE,
                           3, 1,
                           NULL, NULL, NULL,
                           &user->fda));
    PetscCall(DMSetUp(user->fda));
    PetscCall(DMDASetUniformCoordinates(user->fda, 0.0, (PetscReal)(mx - 1), 0.0, (PetscReal)(my - 1), 0.0, (PetscReal)(mz - 1)));
    PetscCall(DMDAGetLocalInfo(user->fda, &user->info));
 
    PetscCall(DMCreateGlobalVector(user->da, &user->P));
    PetscCall(DMCreateLocalVector(user->da, &user->lP));
    PetscCall(DMCreateGlobalVector(user->da, &user->Nvert));
    PetscCall(DMCreateLocalVector(user->da, &user->lNvert));
    PetscCall(DMCreateGlobalVector(user->da, &user->ParticleCount));
    PetscCall(DMCreateLocalVector(user->da, &user->lParticleCount));
    PetscCall(DMCreateGlobalVector(user->da, &user->Psi));
    PetscCall(DMCreateLocalVector(user->da, &user->lPsi));
    PetscCall(DMCreateGlobalVector(user->da, &user->Qcrit));
    PetscCall(DMCreateGlobalVector(user->da, &user->P_nodal));
    PetscCall(DMCreateGlobalVector(user->da, &user->Psi_nodal));
 
    PetscCall(DMCreateGlobalVector(user->fda, &user->Ucat));
    PetscCall(DMCreateLocalVector(user->fda, &user->lUcat));
    PetscCall(DMCreateGlobalVector(user->fda, &user->Ucont));
    PetscCall(DMCreateLocalVector(user->fda, &user->lUcont));
    PetscCall(DMCreateGlobalVector(user->fda, &user->Csi));
    PetscCall(DMCreateLocalVector(user->fda, &user->lCsi));
    PetscCall(DMCreateGlobalVector(user->fda, &user->Eta));
    PetscCall(DMCreateLocalVector(user->fda, &user->lEta));
    PetscCall(DMCreateGlobalVector(user->fda, &user->Zet));
    PetscCall(DMCreateLocalVector(user->fda, &user->lZet));
    PetscCall(DMCreateGlobalVector(user->fda, &user->Cent));
    PetscCall(DMCreateLocalVector(user->fda, &user->lCent));
    PetscCall(DMCreateGlobalVector(user->fda, &user->Ucat_nodal));
 
    PetscCall(VecZeroEntries(user->P));
    PetscCall(VecZeroEntries(user->Nvert));
    PetscCall(VecZeroEntries(user->ParticleCount));
    PetscCall(VecZeroEntries(user->Psi));
    PetscCall(VecZeroEntries(user->Ucat));
    PetscCall(VecZeroEntries(user->Ucont));
    PetscCall(VecZeroEntries(user->Cent));
 
    PetscCall(PicurvPopulateIdentityMetrics(user));
 
    *simCtx_out = simCtx;
    *user_out = user;
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PicurvPopulateIdentityMetrics()

PetscErrorCode PicurvPopulateIdentityMetrics

(

UserCtx *

user

)

Shared test-support routine.

Fills metric vectors with identity metrics for Cartesian-reference tests.

Definition at line 206 of file test_support.c.

{
    Cmpnts ***csi = NULL;
    Cmpnts ***eta = NULL;
    Cmpnts ***zet = NULL;
 
    PetscFunctionBeginUser;
    PetscCall(DMDAVecGetArray(user->fda, user->Csi, &csi));
    PetscCall(DMDAVecGetArray(user->fda, user->Eta, &eta));
    PetscCall(DMDAVecGetArray(user->fda, user->Zet, &zet));
 
    for (PetscInt k = user->info.zs; k < user->info.zs + user->info.zm; ++k) {
        for (PetscInt j = user->info.ys; j < user->info.ys + user->info.ym; ++j) {
            for (PetscInt i = user->info.xs; i < user->info.xs + user->info.xm; ++i) {
                csi[k][j][i].x = 1.0; csi[k][j][i].y = 0.0; csi[k][j][i].z = 0.0;
                eta[k][j][i].x = 0.0; eta[k][j][i].y = 1.0; eta[k][j][i].z = 0.0;
                zet[k][j][i].x = 0.0; zet[k][j][i].y = 0.0; zet[k][j][i].z = 1.0;
            }
        }
    }
 
    PetscCall(DMDAVecRestoreArray(user->fda, user->Csi, &csi));
    PetscCall(DMDAVecRestoreArray(user->fda, user->Eta, &eta));
    PetscCall(DMDAVecRestoreArray(user->fda, user->Zet, &zet));
 
    PetscCall(DMGlobalToLocalBegin(user->fda, user->Csi, INSERT_VALUES, user->lCsi));
    PetscCall(DMGlobalToLocalEnd(user->fda, user->Csi, INSERT_VALUES, user->lCsi));
    PetscCall(DMGlobalToLocalBegin(user->fda, user->Eta, INSERT_VALUES, user->lEta));
    PetscCall(DMGlobalToLocalEnd(user->fda, user->Eta, INSERT_VALUES, user->lEta));
    PetscCall(DMGlobalToLocalBegin(user->fda, user->Zet, INSERT_VALUES, user->lZet));
    PetscCall(DMGlobalToLocalEnd(user->fda, user->Zet, INSERT_VALUES, user->lZet));
    PetscCall(DMGlobalToLocalBegin(user->da, user->Nvert, INSERT_VALUES, user->lNvert));
    PetscCall(DMGlobalToLocalEnd(user->da, user->Nvert, INSERT_VALUES, user->lNvert));
    PetscCall(DMGlobalToLocalBegin(user->da, user->P, INSERT_VALUES, user->lP));
    PetscCall(DMGlobalToLocalEnd(user->da, user->P, INSERT_VALUES, user->lP));
    PetscCall(DMGlobalToLocalBegin(user->da, user->Psi, INSERT_VALUES, user->lPsi));
    PetscCall(DMGlobalToLocalEnd(user->da, user->Psi, INSERT_VALUES, user->lPsi));
    PetscCall(DMGlobalToLocalBegin(user->fda, user->Ucat, INSERT_VALUES, user->lUcat));
    PetscCall(DMGlobalToLocalEnd(user->fda, user->Ucat, INSERT_VALUES, user->lUcat));
    PetscCall(DMGlobalToLocalBegin(user->fda, user->Ucont, INSERT_VALUES, user->lUcont));
    PetscCall(DMGlobalToLocalEnd(user->fda, user->Ucont, INSERT_VALUES, user->lUcont));
    PetscCall(DMGlobalToLocalBegin(user->fda, user->Cent, INSERT_VALUES, user->lCent));
    PetscCall(DMGlobalToLocalEnd(user->fda, user->Cent, INSERT_VALUES, user->lCent));
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

PicurvCreateSwarmPair()

PetscErrorCode PicurvCreateSwarmPair	(	UserCtx *	user,
		PetscInt	nlocal,
		const char *	post_field_name
	)

Shared test-support routine.

Creates paired runtime/post swarms with optional extra post-processing field registration.

Definition at line 255 of file test_support.c.

{
    PetscFunctionBeginUser;
    if (!user) {
        SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_NULL, "UserCtx cannot be NULL.");
    }
 
    PetscCall(DMCreate(PETSC_COMM_WORLD, &user->swarm));
    PetscCall(DMSetType(user->swarm, DMSWARM));
    PetscCall(DMSetDimension(user->swarm, 3));
    PetscCall(DMSwarmSetType(user->swarm, DMSWARM_BASIC));
    PetscCall(DMSwarmSetCellDM(user->swarm, user->da));
    PetscCall(RegisterSwarmFieldForTests(user->swarm, "position", 3, PETSC_REAL));
    PetscCall(RegisterSwarmFieldForTests(user->swarm, "velocity", 3, PETSC_REAL));
    PetscCall(RegisterSwarmFieldForTests(user->swarm, "weight", 3, PETSC_REAL));
    PetscCall(RegisterSwarmFieldForTests(user->swarm, "Psi", 1, PETSC_REAL));
    PetscCall(DMSwarmFinalizeFieldRegister(user->swarm));
    PetscCall(DMSwarmSetLocalSizes(user->swarm, nlocal, 0));
 
    PetscCall(DMCreate(PETSC_COMM_WORLD, &user->post_swarm));
    PetscCall(DMSetType(user->post_swarm, DMSWARM));
    PetscCall(DMSetDimension(user->post_swarm, 3));
    PetscCall(DMSwarmSetType(user->post_swarm, DMSWARM_BASIC));
    PetscCall(DMSwarmSetCellDM(user->post_swarm, user->da));
    PetscCall(RegisterSwarmFieldForTests(user->post_swarm, post_field_name, 1, PETSC_REAL));
    PetscCall(DMSwarmFinalizeFieldRegister(user->post_swarm));
    PetscCall(DMSwarmSetLocalSizes(user->post_swarm, nlocal, 0));
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PicurvDestroyMinimalContexts()

PetscErrorCode PicurvDestroyMinimalContexts	(	SimCtx **	simCtx_ptr,
		UserCtx **	user_ptr
	)

Shared test-support routine.

Destroys contexts previously created by PicurvCreateMinimalContexts.

Definition at line 288 of file test_support.c.

{
    UserCtx *user = NULL;
    SimCtx *simCtx = NULL;
 
    PetscFunctionBeginUser;
    if (user_ptr) {
        user = *user_ptr;
    }
    if (simCtx_ptr) {
        simCtx = *simCtx_ptr;
    }
 
    if (user) {
        PetscCall(DestroyDMIfSet(&user->swarm));
        PetscCall(DestroyDMIfSet(&user->post_swarm));
 
        PetscCall(DestroyVecIfSet(&user->P));
        PetscCall(DestroyVecIfSet(&user->lP));
        PetscCall(DestroyVecIfSet(&user->Phi));
        PetscCall(DestroyVecIfSet(&user->lPhi));
        PetscCall(DestroyVecIfSet(&user->Nvert));
        PetscCall(DestroyVecIfSet(&user->lNvert));
        PetscCall(DestroyVecIfSet(&user->ParticleCount));
        PetscCall(DestroyVecIfSet(&user->lParticleCount));
        PetscCall(DestroyVecIfSet(&user->Psi));
        PetscCall(DestroyVecIfSet(&user->lPsi));
        PetscCall(DestroyVecIfSet(&user->Qcrit));
        PetscCall(DestroyVecIfSet(&user->P_nodal));
        PetscCall(DestroyVecIfSet(&user->Psi_nodal));
        PetscCall(DestroyVecIfSet(&user->Ucat));
        PetscCall(DestroyVecIfSet(&user->lUcat));
        PetscCall(DestroyVecIfSet(&user->Ucont));
        PetscCall(DestroyVecIfSet(&user->lUcont));
        PetscCall(DestroyVecIfSet(&user->Csi));
        PetscCall(DestroyVecIfSet(&user->lCsi));
        PetscCall(DestroyVecIfSet(&user->Eta));
        PetscCall(DestroyVecIfSet(&user->lEta));
        PetscCall(DestroyVecIfSet(&user->Zet));
        PetscCall(DestroyVecIfSet(&user->lZet));
        PetscCall(DestroyVecIfSet(&user->Aj));
        PetscCall(DestroyVecIfSet(&user->lAj));
        PetscCall(DestroyVecIfSet(&user->IAj));
        PetscCall(DestroyVecIfSet(&user->lIAj));
        PetscCall(DestroyVecIfSet(&user->JAj));
        PetscCall(DestroyVecIfSet(&user->lJAj));
        PetscCall(DestroyVecIfSet(&user->KAj));
        PetscCall(DestroyVecIfSet(&user->lKAj));
        PetscCall(DestroyVecIfSet(&user->Diffusivity));
        PetscCall(DestroyVecIfSet(&user->lDiffusivity));
        PetscCall(DestroyVecIfSet(&user->DiffusivityGradient));
        PetscCall(DestroyVecIfSet(&user->lDiffusivityGradient));
        PetscCall(DestroyVecIfSet(&user->Nu_t));
        PetscCall(DestroyVecIfSet(&user->lNu_t));
        PetscCall(DestroyVecIfSet(&user->Cent));
        PetscCall(DestroyVecIfSet(&user->lCent));
        PetscCall(DestroyVecIfSet(&user->Ucat_nodal));
 
        PetscCall(DestroyDMIfSet(&user->da));
        PetscCall(DestroyDMIfSet(&user->fda));
        PetscCall(PetscFree(user));
        if (user_ptr) {
            *user_ptr = NULL;
        }
    }
 
    if (simCtx) {
        PetscCall(PetscFree(simCtx->pps));
        PetscCall(PetscFree(simCtx));
        if (simCtx_ptr) {
            *simCtx_ptr = NULL;
        }
    }
 
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PicurvAssertRealNear()

PetscErrorCode PicurvAssertRealNear	(	PetscReal	expected,
		PetscReal	actual,
		PetscReal	tol,
		const char *	context
	)

Shared test-support routine.

Asserts two real values are within tolerance for test validation.

Definition at line 368 of file test_support.c.

{
    PetscFunctionBeginUser;
    if (PetscAbsReal(expected - actual) > tol) {
        PetscCall(PetscPrintf(PETSC_COMM_WORLD,
                              "[FAIL] %s | expected=%0.12e actual=%0.12e tol=%0.12e\n",
                              context, (double)expected, (double)actual, (double)tol));
        SETERRQ(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Assertion failed.");
    }
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

PicurvAssertIntEqual()

PetscErrorCode PicurvAssertIntEqual	(	PetscInt	expected,
		PetscInt	actual,
		const char *	context
	)

Shared test-support routine.

Asserts two integer values are exactly equal for test validation.

Definition at line 383 of file test_support.c.

{
    PetscFunctionBeginUser;
    if (expected != actual) {
        PetscCall(PetscPrintf(PETSC_COMM_WORLD,
                              "[FAIL] %s | expected=%" PetscInt_FMT " actual=%" PetscInt_FMT "\n",
                              context, expected, actual));
        SETERRQ(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Assertion failed.");
    }
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

PicurvAssertBool()

PetscErrorCode PicurvAssertBool	(	PetscBool	value,
		const char *	context
	)

Shared test-support routine.

Asserts a boolean condition is true for test validation.

Definition at line 398 of file test_support.c.

{
    PetscFunctionBeginUser;
    if (!value) {
        PetscCall(PetscPrintf(PETSC_COMM_WORLD, "[FAIL] %s\n", context));
        SETERRQ(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Assertion failed.");
    }
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

PicurvAssertFileExists()

PetscErrorCode PicurvAssertFileExists	(	const char *	path,
		const char *	context
	)

Shared test-support routine.

Asserts a filesystem path exists.

Definition at line 411 of file test_support.c.

{
    PetscBool exists = PETSC_FALSE;
 
    PetscFunctionBeginUser;
    PetscCall(PetscTestFile(path, 'r', &exists));
    if (!exists) {
        PetscCall(PetscPrintf(PETSC_COMM_WORLD, "[FAIL] %s | missing file: %s\n", context, path));
        SETERRQ(PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Expected file is missing.");
    }
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

PicurvAssertVecConstant()

PetscErrorCode PicurvAssertVecConstant	(	Vec	vec,
		PetscScalar	expected,
		PetscReal	tol,
		const char *	context
	)

Shared test-support routine.

Asserts every entry of a vector equals a constant within tolerance.

Definition at line 427 of file test_support.c.

{
    PetscReal vmin = 0.0;
    PetscReal vmax = 0.0;
 
    PetscFunctionBeginUser;
    PetscCall(VecMin(vec, NULL, &vmin));
    PetscCall(VecMax(vec, NULL, &vmax));
    PetscCall(PicurvAssertRealNear((PetscReal)expected, vmin, tol, context));
    PetscCall(PicurvAssertRealNear((PetscReal)expected, vmax, tol, context));
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function: