# src/test/README

# Test cases

The following test cases are run automatically whenever the code changes.

Note that only the documented test cases appear in the list below (follow the All tests link for a complete list).

## Systems of conservation laws

## Incompressible Euler/Navier–Stokes

- Lid-driven cavity at Re=1000
- Merging of two vertices
- Merging of two vortices (centered Euler solver)
- Taylor–Green vortices

## Shallow-water flows

- Drying of a lake
- Simple Saint-Venant Riemann problem
- Oscillations in a parabolic container
- Undular bores for the Green-Naghdi equations
- Green-Naghdi soliton
- Solitary wave run-up on a plane beach
- Solitary wave overtopping a seawall
- Sinusoidal wave propagation over a bar
- Runup of a solitary wave on a conical island
- Shock reflection by a circular cylinder
- Flow rates for multiple rivers
- Source of a river
- Implicit Saint-Venant solutions for waves
- Viscous hydraulic jump
- Transcritical flow over a bump with multiple layers
- Wind-driven lake
- Lake flowing into itself

## Volume-Of-Fluid

- Computation of volume fractions from a levelset function
- Computation of volume fractions on a variable-resolution grid
- Fractions in marginal cases
- Computation of a levelset field from a contour
- Time-reversed VOF advection in a vortex

## Surface tension

- Curvature of a circular/spherical interface
- Circular droplet in equilibrium
- Capillary wave
- Gravity wave
- Shape oscillation of an inviscid droplet
- Rising bubble

## General orthogonal coordinates

- Circular dam break on a sphere
- Axisymmetric mass conservation
- Axisymmetric Poiseuille flow
- Convergence of axisymmetric viscous terms
- Refinement of axisymmetric metric

## Electrohydrodynamics

- Gouy-Chapman Debye layer
- Electrostatic in planar layers
- Convergence of axisymmetric EHD stresses
- Charge relaxation in an axisymmetric insulated conducting column
- Charge relaxation in a planar cross-section
- Equilibrium of a droplet suspended in an electric field

## Viscoelasticity

- Transient planar Poiseuille flow for an Oldroyd-B or FENE-P fluid
- Oldroyd-B lid-driven cavity
- Viscoelastic 2D drop in a Couette Newtonian shear flow
- Impact of a viscoelastic drop on a solid

## Reaction–Diffusion

## MPI

- Reduction operations
- Boundary conditions and restriction
- Z-order indexing
- Parallel scalability
- Parallel refinement
- Poisson solver on non-uniform mesh
- Boundary conditions for face fluxes
- Boundary conditions for face vector fields
- Simple test of Basilisk View

## Speed benchmarks

## Other

## All tests

# Running and creating test cases (and examples)

First make sure to read the section on Makefiles in the tutorial.

To run a particular test case yourself, you can then just do

```
cd src/test
make bump2D1.tst
```

which should give something like

```
...
qcc -g -O2 -Wall -o bump2D1/bump2D1 bump2D1.c -lm
[bump2D1.tst]
```

This indicates that the test compiled and ran successfully.

## Error checking

If the test fails, you will get something like

```
...
> 2.5 434 0.0678117 0.164104 0.11299303
> # refined 80 cells, coarsened 108 cells
make: *** [bump2D1.tst] Error 1
```

The last line indicates that make failed. The lines before this are the output of

`diff bump2D1/log bump2D1.ref`

That is, to check whether the test case succeeded or not, the default Makefile of Basilisk just compares (using *diff*) the *log* file created by the program to the matching reference log file (with the *.ref* extension).

To create your own test case (let’s call it *mytest*), you only need to create the source code (i.e. *mytest.c*), run it to create the *mytest/log* file, check that you are happy with the results and copy *mytest/log* into *mytest.ref*.

## Graphics

Most tests (but not all) also produce some kind of graph summarising the results (which allows for example to understand more easily how/why a particular test failed). Some tests produce these graphs directly when they run, but most rely on *gnuplot* to generate the graphs in a post-processing step.

This step is not automatically executed when doing *make test.tst*. This allows for example to run the test suite on *bare bones* systems which do not have gnuplot installed.

The makefile system knows about two kinds of graphics: *“inline” plots* and *“offline” plots*.

### Inline plots

These are generated using gnuplot or python commands embedded directly in the documentation comments of the source code (*mytest.c*). Using the standard wiki syntax for scripts these commands appear as

```
~~~gnuplot Caption
set output 'plotname.png'
...
~~~
~~~pythonplot Caption
import matplotlib.pyplot as plt
...
plt.savefig('plot.png')
~~~
```

and are replaced by the corresponding figure when the page is displayed in the wiki. Note that for gnuplot the *set output* command is optional. If you don’t supply a file name, a unique name looking like *_plot1.png* will be generated automatically. For python the *savefig* command is mandatory.

To generate the figures from the command line, just do

`make mytest/plots`

### Offline plots

Alternatively, one can put the gnuplot commands in a separate *mytest.plot* file. Note that this method offers few advantages compared to “inline plots” (the prefered option).

To generate the corresponding plots, one can then do

`make bump2D1/plot.png`

which should give something like

`cd bump2D1 && gnuplot -e "batch=1; PNG=\"pngcairo\" ... ../bump2D1.plot ...`

Note that, while *plot.png* is the default name for the generated graph, the gnuplot script can also generate other graphs. Doing

`ls bump2D1/*.png`

(or * eog bump2D1/*.png*) reveal them all.

Note that if you try to generate plots for a test case which does not have a corresponding *.plot* gnuplot script, you will get something like

```
make events/plot.png
make: *** No rule to make target `events/plot.png'. Stop.
```

## Running the entire test suite

Use something like

```
cd src/test/
make -k -j8
```

where *-k* tells *make* not to stop at the first error and *-j8* uses parallel processing (assuming you have at least 8 cores on your system).

If you want to generate all the graphs at once, do

`make plots`