ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #2157 from akohlmey/use-clang-format-demo

Browse Source 
Demonstrate use of clang-format in LAMMPS
This commit is contained in:
Axel Kohlmeyer
2020-06-15 17:55:42 -04:00
committed by GitHub
parent 4a3d9afb54 30100d33c6
commit a598a66eda
50 changed files with 1788 additions and 1718 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cmake/Modules/CodingStandard.cmake
View File

@ -27,7 +27,7 @@ if (Python3_EXECUTABLE)
COMMENT "Fix whitespace errors")
add_custom_target(
fix-permissions
${Python3_EXECUTABLE} ${LAMMPS_TOOLS_DIR}/coding_standard/permission.py -f .
${Python3_EXECUTABLE} ${LAMMPS_TOOLS_DIR}/coding_standard/permissions.py -f .
WORKING_DIRECTORY ${LAMMPS_DIR}
COMMENT "Fix permission errors")
endif()

46
cmake/Modules/FindClangFormat.cmake Normal file
View File

@ -0,0 +1,46 @@
# Find clang-format
find_program(ClangFormat_EXECUTABLE NAMES clang-format
clang-format-10.0
clang-format-9.0
clang-format-8.0
clang-format-7.0
clang-format-6.0
DOC "clang-format executable")
mark_as_advanced(ClangFormat_EXECUTABLE)
if(ClangFormat_EXECUTABLE)
# find version
execute_process(COMMAND ${ClangFormat_EXECUTABLE} --version
OUTPUT_VARIABLE clang_format_version
ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
if(clang_format_version MATCHES "^clang-format version .*")
# Arch Linux
# clang-format version 10.0.0
# Ubuntu 18.04 LTS Output
# clang-format version 6.0.0-1ubuntu2 (tags/RELEASE_600/final)
string(REGEX REPLACE "clang-format version ([0-9.]+).*"
"\\1"
ClangFormat_VERSION
"${clang_format_version}")
elseif(clang_format_version MATCHES ".*LLVM version .*")
# CentOS 7 Output
# LLVM (http://llvm.org/):
# LLVM version 3.4.2
# Optimized build.
# Built Nov 1 2018 (15:06:24).
# Default target: x86_64-redhat-linux-gnu
# Host CPU: x86-64
string(REGEX REPLACE ".*LLVM version ([0-9.]+).*"
"\\1"
ClangFormat_VERSION
"${clang_format_version}")
else()
set(ClangFormat_VERSION "0.0")
endif()
endif()
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(ClangFormat REQUIRED_VARS ClangFormat_EXECUTABLE VERSION_VAR ClangFormat_VERSION)

0
examples/USER/atc/elastic/in.no_atoms Executable file → Normal file
View File

0
examples/USER/atc/elastic/in.no_atoms_cb Executable file → Normal file
View File

0
examples/USER/atc/elastic/in.no_atoms_cb_linear Executable file → Normal file
View File

0
examples/USER/atc/molecule/in.polarize Executable file → Normal file
View File

0
examples/USER/dpd/dpdrx-shardlow/in.dpdrx-shardlow Executable file → Normal file
View File

0
examples/USER/lb/confined_colloid/in.confined_colloids Executable file → Normal file
View File

0
examples/USER/lb/dragforce/in.defaultgamma_drag Executable file → Normal file
View File

0
examples/USER/lb/dragforce/in.setgamma_drag Executable file → Normal file
View File

0
examples/USER/lb/fourspheres/in.fourspheres_default_gamma Executable file → Normal file
View File

0
examples/USER/lb/fourspheres/in.fourspheres_set_gamma Executable file → Normal file
View File

0
examples/USER/lb/microrheology/in.microrheology_default_gamma Executable file → Normal file
View File

0
examples/USER/lb/microrheology/in.microrheology_set_gamma Executable file → Normal file
View File

0
examples/USER/lb/planewall/in.planewall_default_gamma Executable file → Normal file
View File

0
examples/USER/lb/planewall/in.planewall_set_gamma Executable file → Normal file
View File

0
examples/USER/phonon/dynamical_matrix_command/Silicon/README.md Executable file → Normal file
View File

0
examples/USER/phonon/dynamical_matrix_command/Silicon/in.silicon Executable file → Normal file
View File

0
examples/USER/phonon/dynamical_matrix_command/python/README.md Executable file → Normal file
View File

26
src/USER-INTEL/TEST/README
View File

@ -1,11 +1,11 @@
#############################################################################
# Benchmarks
#
# in.intel.lj - Atomic fluid (LJ Benchmark)
# in.intel.lj - Atomic fluid (LJ Benchmark)
# in.intel.rhodo - Protein (Rhodopsin Benchmark)
# in.intel.lc - Liquid Crystal w/ Gay-Berne potential
# in.intel.eam - Copper benchmark with Embedded Atom Method
# in.intel.sw - Silicon benchmark with Stillinger-Weber
# in.intel.lc - Liquid Crystal w/ Gay-Berne potential
# in.intel.eam - Copper benchmark with Embedded Atom Method
# in.intel.sw - Silicon benchmark with Stillinger-Weber
# in.intel.tersoff - Silicon benchmark with Tersoff
# in.intel.water - Coarse-grain water benchmark using Stillinger-Weber
# in.intel.airebo - Polyethelene benchmark with AIREBO
@ -21,9 +21,9 @@
#
# in.intel.lj - 199.5 282.3 317.3
# in.intel.rhodo - 12.4 17.5 24.4
# in.intel.lc - 19.0 25.7 26.8
# in.intel.lc - 19.0 25.7 26.8
# in.intel.eam - 59.4 92.8 105.6
# in.intel.sw - 132.4 161.9 213.8
# in.intel.sw - 132.4 161.9 213.8
# in.intel.tersoff - 83.3 101.1 109.6
# in.intel.water - 53.4 90.3 105.5
# in.intel.airebo - 7.3 11.8 17.6
@ -50,24 +50,24 @@
# the Intel package. You can specify a multiplier for all of the benchmarks
# to increase or decrease the runtime. Example commandline arguments:
#
# -v m 2 # Run for twice as long
# -v m 0.5 # Run for half as long
# -v m 2 # Run for twice as long
# -v m 0.5 # Run for half as long
#############################################################################
#############################################################################
# The LAMMPS newton setting can be controlled from the commandline for the
# benchmarks with the N variable:
#
# -v N on # newton on
# -v N off # newton off
# -v N on # newton on
# -v N off # newton off
#
# The default is on for all of the benchmarks except for LJ where the off
# setting performs best with the USER-INTEL package
#############################################################################
# Example for running benchmarks (see run_benchmarks.sh for script):
# Example for running benchmarks (see run_benchmarks.sh for script):
# Number of physical cores per node not including hyperthreads
# Number of physical cores per node not including hyperthreads
export LMP_CORES=28
# If hyperthreading is enabled, number of hyperthreads to use per core
@ -83,7 +83,7 @@ export LMP_ROOT=../../../
source source /opt/intel/parallel_studio_xe_2017.2.050/psxevars.sh
export KMP_BLOCKTIME=0
export I_MPI_PIN_DOMAIN=core
export I_MPI_FABRICS=shm # For single node
export I_MPI_FABRICS=shm # For single node
# ONLY FOR INTEL XEON PHI x200 SERIES PROCESSORS
export I_MPI_SHM_LMT=shm

78
src/USER-QTB/README
View File

@ -3,54 +3,54 @@ This package contains 2 fix commands, "fix qtb" and
What is quantum nuclear effects (in molecular dynamics
simulation)?
Quantum treatment of the vibrational modes will
introduce zero point energy into the system, alter
the energy power spectrum and bias the heat capacity
from the classical limit. classical MD leaves out
these effects completely and thus need to be corrected.
Quantum treatment of the vibrational modes will
introduce zero point energy into the system, alter
the energy power spectrum and bias the heat capacity
from the classical limit. classical MD leaves out
these effects completely and thus need to be corrected.
When should I consider quantum nuclear effects in
my simulation?
(1) When you want to model systems at temperatures
lower than their classical limits. This is especially
important for materials with a large population of
hydrogen atoms and thus higher classical limits.
(1) When you want to model systems at temperatures
lower than their classical limits. This is especially
important for materials with a large population of
hydrogen atoms and thus higher classical limits.
(2) In MD simulations when temperatures ramp up
across (or starting from somewhere close to) the
classical limits, tiny differences between the
classical and quantum heat capacity can accumulate
and cause the final state to deviate (could be as
large as 30 %).
(2) In MD simulations when temperatures ramp up
across (or starting from somewhere close to) the
classical limits, tiny differences between the
classical and quantum heat capacity can accumulate
and cause the final state to deviate (could be as
large as 30 %).
What command should I use regarding these two cases?
(1) "fix qtb" provides quantum nulcear correction
through a colored thermostat and can be used with
other time integration schemes like fix nve or
fix nph. In this case, you tell "fix qtb" the temperature
and the other time integration scheme either the
pressure ("fix nph") or the volume ("fix nve").
(1) "fix qtb" provides quantum nulcear correction
through a colored thermostat and can be used with
other time integration schemes like fix nve or
fix nph. In this case, you tell "fix qtb" the temperature
and the other time integration scheme either the
pressure ("fix nph") or the volume ("fix nve").
(2) "fix qbmsst" deals with shock MD simulations
in which cases the temperature may increase a lot.
It enables quantum nuclear correction of a multi-scale
shock technique simulation by coupling the quantum
thermal bath with the shocked system. It is an independent
command from "fix msst" and does not assume that
the SHOCK package has been installed.
(2) "fix qbmsst" deals with shock MD simulations
in which cases the temperature may increase a lot.
It enables quantum nuclear correction of a multi-scale
shock technique simulation by coupling the quantum
thermal bath with the shocked system. It is an independent
command from "fix msst" and does not assume that
the SHOCK package has been installed.
See the doc page for the fix qtb and fix qbmsst
command for detailed usage instructions.
See the doc page for the fix qtb and fix qbmsst
command for detailed usage instructions.
Where can I find examples of these two commands?
There are example scripts for using this package in
examples/USER/qtb, including one "fix qtb" and one
"fix qbmsst" example for each of alpha quartz and
methane. Running the alpha quartz example requires
installation of the kspace package while the methane
example requires the REAX package for the force field.
There are example scripts for using this package in
examples/USER/qtb, including one "fix qtb" and one
"fix qbmsst" example for each of alpha quartz and
methane. Running the alpha quartz example requires
installation of the kspace package while the methane
example requires the REAX package for the force field.
Authors Information and Contact
The person who created this package is Yuan Shen
(sy0302 at stanford.edu) at Stanford University.
Contact him directly if you have questions.
The person who created this package is Yuan Shen
(sy0302 at stanford.edu) at Stanford University.
Contact him directly if you have questions.

23
unittest/.clang-format Normal file
View File

@ -0,0 +1,23 @@
---
Language: Cpp
BasedOnStyle: LLVM
AccessModifierOffset: -4
AlignConsecutiveAssignments: true
AlignEscapedNewlines: Left
AllowShortFunctionsOnASingleLine: Inline
AllowShortLambdasOnASingleLine: None
AllowShortIfStatementsOnASingleLine: WithoutElse
BraceWrapping:
AfterFunction: true
BreakBeforeBraces: Custom
BreakInheritanceList: AfterColon
BreakConstructorInitializers: AfterColon
ColumnLimit: 100
IndentCaseLabels: true
IndentWidth: 4
ObjCBlockIndentWidth: 4
PenaltyBreakAssignment: 4
Standard: Cpp11
TabWidth: 4
UseTab: Never
...

10
unittest/CMakeLists.txt
View File

@ -5,3 +5,13 @@ add_subdirectory(force-styles)
add_subdirectory(utils)
add_subdirectory(formats)
find_package(ClangFormat 8.0)
if(ClangFormat_FOUND)
set(UNITTEST_SOURCES)
file(GLOB_RECURSE UNITTEST_SOURCES *.cpp *.h)
add_custom_target(format-tests
COMMAND ${ClangFormat_EXECUTABLE} --verbose -i -style=file ${UNITTEST_SOURCES}
DEPENDS ${UNITTEST_SOURCES})
endif()

2
unittest/force-styles/CMakeLists.txt
View File

@ -8,6 +8,7 @@ endif()
set(TEST_INPUT_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/tests)
add_library(style_tests STATIC yaml_writer.cpp error_stats.cpp test_config_reader.cpp test_main.cpp)
target_compile_definitions(style_tests PRIVATE TEST_INPUT_FOLDER=${TEST_INPUT_FOLDER})
target_include_directories(style_tests PRIVATE ${LAMMPS_SOURCE_DIR})
target_link_libraries(style_tests PUBLIC GTest::GTest GTest::GMock Yaml::Yaml)
if(BUILD_MPI)
target_link_libraries(style_tests PUBLIC MPI::MPI_CXX)
@ -17,6 +18,7 @@ endif()
# unit test for error stats class
add_executable(test_error_stats test_error_stats.cpp)
target_include_directories(test_error_stats PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} ${LAMMPS_SOURCE_DIR})
target_link_libraries(test_error_stats PRIVATE GTest::GTestMain GTest::GTest)
add_test(NAME ErrorStats COMMAND test_error_stats)

516
unittest/force-styles/angle_style.cpp
View File

File diff suppressed because it is too large Load Diff

722
unittest/force-styles/bond_style.cpp
View File

File diff suppressed because it is too large Load Diff

43
unittest/force-styles/error_stats.cpp
View File

@ -12,49 +12,42 @@
------------------------------------------------------------------------- */
#include "error_stats.h"
#include "fmt/format.h"
#include <cmath>
#include <iostream>
#include <string>
#include <cmath>
void ErrorStats::reset() {
num = 0;
void ErrorStats::reset()
{
num = 0;
maxidx = -1;
sum = sumsq = maxerr =0.0;
sum = sumsq = maxerr = 0.0;
}
void ErrorStats::add(const double &val) {
void ErrorStats::add(const double &val)
{
++num;
if (val > maxerr) {
maxidx = num;
maxerr = val;
}
sum += val;
sumsq += val*val;
sumsq += val * val;
}
double ErrorStats::avg() const {
return (num > 0) ? sum/num : 0.0;
double ErrorStats::avg() const
{
return (num > 0) ? sum / num : 0.0;
}
double ErrorStats::dev() const {
return (num > 0) ? sqrt(sumsq/num - sum/num*sum/num) : 0.0;
double ErrorStats::dev() const
{
return (num > 0) ? sqrt(sumsq / num - sum / num * sum / num) : 0.0;
}
std::ostream &operator<<(std::ostream &out, const ErrorStats &stats)
{
const std::ios_base::fmtflags flags = out.flags();
const std::streamsize width = out.width(10);
const std::streamsize prec = out.precision(3);
out << std::scientific
<< "Average: " << stats.avg()
<< " StdDev: " << stats.dev()
<< " MaxErr: " << stats.max();
out.precision(prec);
out.width(width);
out.flags(flags);
return out << " @ item: " << stats.idx();
out << fmt::format("Average: {:10.3e} StdDev: {:10.3e} MaxErr: {:10.3e} @ item: {}",
stats.avg(), stats.dev(), stats.max(), stats.idx());
return out;
}

8
unittest/force-styles/error_stats.h
View File

@ -20,9 +20,7 @@ class ErrorStats {
public:
friend std::ostream &operator<<(std::ostream &out, const ErrorStats &stats);
ErrorStats() {
reset();
}
ErrorStats() { reset(); }
virtual ~ErrorStats() {}
void reset();
@ -33,8 +31,8 @@ public:
double idx() const { return maxidx; }
private:
double sum,sumsq,maxerr;
int num,maxidx;
double sum, sumsq, maxerr;
int num, maxidx;
};
extern std::ostream &operator<<(std::ostream &out, const ErrorStats &stats);

874
unittest/force-styles/pair_style.cpp
View File

File diff suppressed because it is too large Load Diff

39
unittest/force-styles/test_config.h
View File

@ -19,11 +19,11 @@
#include <vector>
struct coord_t {
double x,y,z;
double x, y, z;
};
struct stress_t {
double xx,yy,zz,xy,xz,yz;
double xx, yy, zz, xy, xz, yz;
};
class TestConfig {
@ -32,7 +32,7 @@ public:
std::string date_generated;
std::string basename;
double epsilon;
std::vector<std::pair<std::string,std::string>> prerequisites;
std::vector<std::pair<std::string, std::string>> prerequisites;
std::vector<std::string> pre_commands;
std::vector<std::string> post_commands;
std::string input_file;
@ -48,7 +48,7 @@ public:
std::vector<std::string> dihedral_coeff;
std::vector<std::string> improper_coeff;
std::vector<double> equilibrium;
std::vector<std::pair<std::string,int>> extract;
std::vector<std::pair<std::string, int>> extract;
int natoms;
double init_energy;
double run_energy;
@ -61,26 +61,13 @@ public:
std::vector<coord_t> init_forces;
std::vector<coord_t> run_forces;
TestConfig() : lammps_version(""),
date_generated(""),
basename(""),
epsilon(1.0e-14),
input_file(""),
pair_style("zero"),
bond_style("zero"),
angle_style("zero"),
dihedral_style("zero"),
improper_style("zero"),
kspace_style("none"),
natoms(0),
init_energy(0),
run_energy(0),
init_vdwl(0),
run_vdwl(0),
init_coul(0),
run_coul(0),
init_stress({0,0,0,0,0,0}),
run_stress({0,0,0,0,0,0}) {
TestConfig() :
lammps_version(""), date_generated(""), basename(""), epsilon(1.0e-14), input_file(""),
pair_style("zero"), bond_style("zero"), angle_style("zero"), dihedral_style("zero"),
improper_style("zero"), kspace_style("none"), natoms(0), init_energy(0), run_energy(0),
init_vdwl(0), run_vdwl(0), init_coul(0), run_coul(0), init_stress({0, 0, 0, 0, 0, 0}),
run_stress({0, 0, 0, 0, 0, 0})
{
prerequisites.clear();
pre_commands.clear();
post_commands.clear();
@ -93,10 +80,10 @@ public:
init_forces.clear();
run_forces.clear();
}
virtual ~TestConfig() {};
virtual ~TestConfig(){};
private:
TestConfig(const TestConfig &) {};
TestConfig(const TestConfig &){};
};
#endif

149
unittest/force-styles/test_config_reader.cpp
View File

@ -11,22 +11,22 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "test_config.h"
#include "test_config_reader.h"
#include "yaml_reader.h"
#include "test_config.h"
#include "yaml.h"
#include "yaml_reader.h"
#include <cstring>
#include <cstdlib>
#include <cstring>
#include <string>
#include <iostream>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
TestConfigReader::TestConfigReader(TestConfig & config)
: YamlReader(), config(config) {
TestConfigReader::TestConfigReader(TestConfig &config) : YamlReader(), config(config)
{
consumers["lammps_version"] = &TestConfigReader::lammps_version;
consumers["date_generated"] = &TestConfigReader::date_generated;
consumers["epsilon"] = &TestConfigReader::epsilon;
@ -41,45 +41,48 @@ TestConfigReader::TestConfigReader(TestConfig & config)
consumers["init_forces"] = &TestConfigReader::init_forces;
consumers["run_forces"] = &TestConfigReader::run_forces;
consumers["pair_style"] = &TestConfigReader::pair_style;
consumers["pair_coeff"] = &TestConfigReader::pair_coeff;
consumers["init_vdwl"] = &TestConfigReader::init_vdwl;
consumers["init_coul"] = &TestConfigReader::init_coul;
consumers["run_vdwl"] = &TestConfigReader::run_vdwl;
consumers["run_coul"] = &TestConfigReader::run_coul;
consumers["pair_style"] = &TestConfigReader::pair_style;
consumers["pair_coeff"] = &TestConfigReader::pair_coeff;
consumers["init_vdwl"] = &TestConfigReader::init_vdwl;
consumers["init_coul"] = &TestConfigReader::init_coul;
consumers["run_vdwl"] = &TestConfigReader::run_vdwl;
consumers["run_coul"] = &TestConfigReader::run_coul;
consumers["bond_style"] = &TestConfigReader::bond_style;
consumers["bond_coeff"] = &TestConfigReader::bond_coeff;
consumers["angle_style"] = &TestConfigReader::angle_style;
consumers["angle_coeff"] = &TestConfigReader::angle_coeff;
consumers["init_energy"] = &TestConfigReader::init_energy;
consumers["run_energy"] = &TestConfigReader::run_energy;
consumers["equilibrium"] = &TestConfigReader::equilibrium;
consumers["bond_style"] = &TestConfigReader::bond_style;
consumers["bond_coeff"] = &TestConfigReader::bond_coeff;
consumers["angle_style"] = &TestConfigReader::angle_style;
consumers["angle_coeff"] = &TestConfigReader::angle_coeff;
consumers["init_energy"] = &TestConfigReader::init_energy;
consumers["run_energy"] = &TestConfigReader::run_energy;
consumers["equilibrium"] = &TestConfigReader::equilibrium;
}
void TestConfigReader::prerequisites(const yaml_event_t & event) {
void TestConfigReader::prerequisites(const yaml_event_t &event)
{
config.prerequisites.clear();
std::stringstream data((char *)event.data.scalar.value);
std::string key, value;
while(1) {
while (1) {
data >> key >> value;
if (data.eof()) break;
config.prerequisites.push_back(std::make_pair(key,value));
config.prerequisites.push_back(std::make_pair(key, value));
}
}
void TestConfigReader::pre_commands(const yaml_event_t & event) {
void TestConfigReader::pre_commands(const yaml_event_t &event)
{
config.pre_commands.clear();
std::stringstream data((char *)event.data.scalar.value);
std::string line;
while(std::getline(data, line, '\n')) {
while (std::getline(data, line, '\n')) {
config.pre_commands.push_back(line);
}
}
void TestConfigReader::post_commands(const yaml_event_t & event) {
void TestConfigReader::post_commands(const yaml_event_t &event)
{
config.post_commands.clear();
std::stringstream data((char *)event.data.scalar.value);
std::string line;
@ -89,63 +92,68 @@ void TestConfigReader::post_commands(const yaml_event_t & event) {
}
}
void TestConfigReader::lammps_version(const yaml_event_t & event) {
void TestConfigReader::lammps_version(const yaml_event_t &event)
{
config.lammps_version = (char *)event.data.scalar.value;
}
void TestConfigReader::date_generated(const yaml_event_t & event) {
void TestConfigReader::date_generated(const yaml_event_t &event)
{
config.date_generated = (char *)event.data.scalar.value;
}
void TestConfigReader::epsilon(const yaml_event_t & event) {
void TestConfigReader::epsilon(const yaml_event_t &event)
{
config.epsilon = atof((char *)event.data.scalar.value);
}
void TestConfigReader::input_file(const yaml_event_t & event) {
void TestConfigReader::input_file(const yaml_event_t &event)
{
config.input_file = (char *)event.data.scalar.value;
}
void TestConfigReader::extract(const yaml_event_t & event) {
void TestConfigReader::extract(const yaml_event_t &event)
{
config.extract.clear();
std::stringstream data((char *)event.data.scalar.value);
std::string name;
int value;
while(1) {
while (1) {
data >> name >> value;
if (data.eof()) break;
config.extract.push_back(make_pair(name, value));
}
}
void TestConfigReader::natoms(const yaml_event_t & event) {
void TestConfigReader::natoms(const yaml_event_t &event)
{
config.natoms = atoi((char *)event.data.scalar.value);
}
void TestConfigReader::init_stress(const yaml_event_t & event) {
void TestConfigReader::init_stress(const yaml_event_t &event)
{
stress_t stress;
sscanf((char *)event.data.scalar.value,
"%lg %lg %lg %lg %lg %lg",
&stress.xx, &stress.yy, &stress.zz,
&stress.xy, &stress.xz, &stress.yz);
sscanf((char *)event.data.scalar.value, "%lg %lg %lg %lg %lg %lg", &stress.xx, &stress.yy,
&stress.zz, &stress.xy, &stress.xz, &stress.yz);
config.init_stress = stress;
}
void TestConfigReader::run_stress(const yaml_event_t & event) {
void TestConfigReader::run_stress(const yaml_event_t &event)
{
stress_t stress;
sscanf((char *)event.data.scalar.value,
"%lg %lg %lg %lg %lg %lg",
&stress.xx, &stress.yy, &stress.zz,
&stress.xy, &stress.xz, &stress.yz);
sscanf((char *)event.data.scalar.value, "%lg %lg %lg %lg %lg %lg", &stress.xx, &stress.yy,
&stress.zz, &stress.xy, &stress.xz, &stress.yz);
config.run_stress = stress;
}
void TestConfigReader::init_forces(const yaml_event_t & event) {
void TestConfigReader::init_forces(const yaml_event_t &event)
{
config.init_forces.clear();
config.init_forces.resize(config.natoms+1);
std::stringstream data((const char*)event.data.scalar.value);
config.init_forces.resize(config.natoms + 1);
std::stringstream data((const char *)event.data.scalar.value);
std::string line;
while(std::getline(data, line, '\n')) {
while (std::getline(data, line, '\n')) {
int tag = 0;
coord_t xyz;
sscanf(line.c_str(), "%d %lg %lg %lg", &tag, &xyz.x, &xyz.y, &xyz.z);
@ -153,13 +161,14 @@ void TestConfigReader::init_forces(const yaml_event_t & event) {
}
}
void TestConfigReader::run_forces(const yaml_event_t & event) {
void TestConfigReader::run_forces(const yaml_event_t &event)
{
config.run_forces.clear();
config.run_forces.resize(config.natoms+1);
config.run_forces.resize(config.natoms + 1);
std::stringstream data((char *)event.data.scalar.value);
std::string line;
while(std::getline(data, line, '\n')) {
while (std::getline(data, line, '\n')) {
int tag;
coord_t xyz;
sscanf(line.c_str(), "%d %lg %lg %lg", &tag, &xyz.x, &xyz.y, &xyz.z);
@ -167,11 +176,13 @@ void TestConfigReader::run_forces(const yaml_event_t & event) {
}
}
void TestConfigReader::pair_style(const yaml_event_t & event) {
void TestConfigReader::pair_style(const yaml_event_t &event)
{
config.pair_style = (char *)event.data.scalar.value;
}
void TestConfigReader::pair_coeff(const yaml_event_t & event) {
void TestConfigReader::pair_coeff(const yaml_event_t &event)
{
config.pair_coeff.clear();
std::stringstream data((char *)event.data.scalar.value);
std::string line;
@ -181,11 +192,13 @@ void TestConfigReader::pair_coeff(const yaml_event_t & event) {
}
}
void TestConfigReader::bond_style(const yaml_event_t & event) {
void TestConfigReader::bond_style(const yaml_event_t &event)
{
config.bond_style = (char *)event.data.scalar.value;
}
void TestConfigReader::bond_coeff(const yaml_event_t & event) {
void TestConfigReader::bond_coeff(const yaml_event_t &event)
{
config.bond_coeff.clear();
std::stringstream data((char *)event.data.scalar.value);
std::string line;
@ -195,11 +208,13 @@ void TestConfigReader::bond_coeff(const yaml_event_t & event) {
}
}
void TestConfigReader::angle_style(const yaml_event_t & event) {
void TestConfigReader::angle_style(const yaml_event_t &event)
{
config.angle_style = (char *)event.data.scalar.value;
}
void TestConfigReader::angle_coeff(const yaml_event_t & event) {
void TestConfigReader::angle_coeff(const yaml_event_t &event)
{
config.angle_coeff.clear();
std::stringstream data((char *)event.data.scalar.value);
std::string line;
@ -209,40 +224,46 @@ void TestConfigReader::angle_coeff(const yaml_event_t & event) {
}
}
void TestConfigReader::equilibrium(const yaml_event_t & event) {
void TestConfigReader::equilibrium(const yaml_event_t &event)
{
std::stringstream data((char *)event.data.scalar.value);
config.equilibrium.clear();
double value;
std::size_t num;
data >> num;
for (std::size_t i=0; i < num; ++i) {
for (std::size_t i = 0; i < num; ++i) {
data >> value;
if (data.eof()) break;
config.equilibrium.push_back(value);
}
}
void TestConfigReader::init_vdwl(const yaml_event_t & event) {
void TestConfigReader::init_vdwl(const yaml_event_t &event)
{
config.init_vdwl = atof((char *)event.data.scalar.value);
}
void TestConfigReader::init_coul(const yaml_event_t & event) {
void TestConfigReader::init_coul(const yaml_event_t &event)
{
config.init_coul = atof((char *)event.data.scalar.value);
}
void TestConfigReader::run_vdwl(const yaml_event_t & event) {
void TestConfigReader::run_vdwl(const yaml_event_t &event)
{
config.run_vdwl = atof((char *)event.data.scalar.value);
}
void TestConfigReader::run_coul(const yaml_event_t & event) {
void TestConfigReader::run_coul(const yaml_event_t &event)
{
config.run_coul = atof((char *)event.data.scalar.value);
}
void TestConfigReader::init_energy(const yaml_event_t & event) {
void TestConfigReader::init_energy(const yaml_event_t &event)
{
config.init_energy = atof((char *)event.data.scalar.value);
}
void TestConfigReader::run_energy(const yaml_event_t & event) {
void TestConfigReader::run_energy(const yaml_event_t &event)
{
config.run_energy = atof((char *)event.data.scalar.value);
}

57
unittest/force-styles/test_config_reader.h
View File

@ -14,40 +14,41 @@
#ifndef TEST_CONFIG_READER_H
#define TEST_CONFIG_READER_H
#include "test_config.h"
#include "yaml_reader.h"
class TestConfigReader : public YamlReader<TestConfigReader> {
TestConfig & config;
TestConfig &config;
public:
TestConfigReader(TestConfig & config);
TestConfigReader(TestConfig &config);
void prerequisites(const yaml_event_t & event);
void pre_commands(const yaml_event_t & event);
void post_commands(const yaml_event_t & event);
void lammps_version(const yaml_event_t & event);
void date_generated(const yaml_event_t & event);
void epsilon(const yaml_event_t & event);
void input_file(const yaml_event_t & event);
void extract(const yaml_event_t & event);
void natoms(const yaml_event_t & event);
void init_stress(const yaml_event_t & event);
void run_stress(const yaml_event_t & event);
void init_forces(const yaml_event_t & event);
void run_forces(const yaml_event_t & event);
void pair_style(const yaml_event_t & event);
void pair_coeff(const yaml_event_t & event);
void bond_style(const yaml_event_t & event);
void bond_coeff(const yaml_event_t & event);
void angle_style(const yaml_event_t & event);
void angle_coeff(const yaml_event_t & event);
void equilibrium(const yaml_event_t & event);
void init_vdwl(const yaml_event_t & event);
void init_coul(const yaml_event_t & event);
void run_vdwl(const yaml_event_t & event);
void run_coul(const yaml_event_t & event);
void init_energy(const yaml_event_t & event);
void run_energy(const yaml_event_t & event);
void prerequisites(const yaml_event_t &event);
void pre_commands(const yaml_event_t &event);
void post_commands(const yaml_event_t &event);
void lammps_version(const yaml_event_t &event);
void date_generated(const yaml_event_t &event);
void epsilon(const yaml_event_t &event);
void input_file(const yaml_event_t &event);
void extract(const yaml_event_t &event);
void natoms(const yaml_event_t &event);
void init_stress(const yaml_event_t &event);
void run_stress(const yaml_event_t &event);
void init_forces(const yaml_event_t &event);
void run_forces(const yaml_event_t &event);
void pair_style(const yaml_event_t &event);
void pair_coeff(const yaml_event_t &event);
void bond_style(const yaml_event_t &event);
void bond_coeff(const yaml_event_t &event);
void angle_style(const yaml_event_t &event);
void angle_coeff(const yaml_event_t &event);
void equilibrium(const yaml_event_t &event);
void init_vdwl(const yaml_event_t &event);
void init_coul(const yaml_event_t &event);
void run_vdwl(const yaml_event_t &event);
void run_coul(const yaml_event_t &event);
void init_energy(const yaml_event_t &event);
void run_energy(const yaml_event_t &event);
};
#endif

5
unittest/force-styles/test_error_stats.cpp
View File

@ -5,8 +5,9 @@
// include the implementation since ErrorStats is a standalone class
// this way we don't have to link against the style_tests and lammps libs
#include "error_stats.cpp"
#include "fmtlib_format.cpp"
#include "fmtlib_os.cpp"
TEST(ErrorStats, test)
{
@ -25,7 +26,7 @@ TEST(ErrorStats, test)
std::stringstream out;
out << stats;
ASSERT_EQ(out.str(), " Average: 5.800e-01 StdDev: 7.305e-01 MaxErr: 2.000e+00 @ item: 3");
ASSERT_EQ(out.str(), "Average: 5.800e-01 StdDev: 7.305e-01 MaxErr: 2.000e+00 @ item: 3.0");
stats.reset();
ASSERT_DOUBLE_EQ(stats.avg(), 0.0);

29
unittest/force-styles/test_main.cpp
View File

@ -16,16 +16,15 @@
#include "test_config_reader.h"
#include "gtest/gtest.h"
#include <mpi.h>
#include <cstring>
#include <iostream>
#include <mpi.h>
// common read_yaml_file function
bool read_yaml_file(const char *infile, TestConfig &config)
{
auto reader = TestConfigReader(config);
if (reader.parse_file(infile))
return false;
if (reader.parse_file(infile)) return false;
config.basename = reader.get_basename();
return true;
@ -76,32 +75,32 @@ int main(int argc, char **argv)
return 2;
}
int iarg=2;
int iarg = 2;
while (iarg < argc) {
if (strcmp(argv[iarg],"-g") == 0) {
if (iarg+1 < argc) {
generate_yaml_file(argv[iarg+1], test_config);
if (strcmp(argv[iarg], "-g") == 0) {
if (iarg + 1 < argc) {
generate_yaml_file(argv[iarg + 1], test_config);
return 0;
} else {
usage(std::cerr,argv[0]);
usage(std::cerr, argv[0]);
return 1;
}
} else if (strcmp(argv[iarg],"-u") == 0) {
} else if (strcmp(argv[iarg], "-u") == 0) {
generate_yaml_file(argv[1], test_config);
return 0;
} else if (strcmp(argv[iarg],"-d") == 0) {
if (iarg+1 < argc) {
INPUT_FOLDER = argv[iarg+1];
} else if (strcmp(argv[iarg], "-d") == 0) {
if (iarg + 1 < argc) {
INPUT_FOLDER = argv[iarg + 1];
iarg += 2;
} else {
usage(std::cerr,argv[0]);
usage(std::cerr, argv[0]);
return 1;
}
} else if (strcmp(argv[iarg],"-s") == 0) {
} else if (strcmp(argv[iarg], "-s") == 0) {
print_stats = true;
++iarg;
} else if (strcmp(argv[iarg],"-v") == 0) {
} else if (strcmp(argv[iarg], "-v") == 0) {
verbose = true;
++iarg;
} else {

14
unittest/force-styles/test_main.h
View File

@ -22,13 +22,13 @@ extern bool print_stats;
extern bool verbose;
extern std::string INPUT_FOLDER;
#define EXPECT_FP_LE_WITH_EPS(val1,val2,eps) \
do { \
const double diff = fabs(val1-val2); \
const double div = std::min(fabs(val1),fabs(val2)); \
const double err = (div == 0.0) ? diff : diff/div; \
stats.add(err); \
EXPECT_PRED_FORMAT2(::testing::DoubleLE, err, eps); \
#define EXPECT_FP_LE_WITH_EPS(val1, val2, eps) \
do { \
const double diff = fabs(val1 - val2); \
const double div = std::min(fabs(val1), fabs(val2)); \
const double err = (div == 0.0) ? diff : diff / div; \
stats.add(err); \
EXPECT_PRED_FORMAT2(::testing::DoubleLE, err, eps); \
} while (0);
#endif

155
unittest/force-styles/yaml_reader.h
View File

@ -17,11 +17,11 @@
#include "yaml.h"
#include <cstdio>
#include <iostream>
#include <map>
#include <string>
#include <iostream>
template<typename ConsumerClass> class YamlReader {
template <typename ConsumerClass> class YamlReader {
private:
enum StateValue {
START,
@ -37,7 +37,7 @@ private:
std::string basename;
protected:
typedef void (ConsumerClass::*EventConsumer)(const yaml_event_t & event);
typedef void (ConsumerClass::*EventConsumer)(const yaml_event_t &event);
std::map<std::string, EventConsumer> consumers;
public:
@ -46,20 +46,21 @@ public:
std::string get_basename() const { return basename; }
int parse_file(const std::string & infile) {
basename = infile;
int parse_file(const std::string &infile)
{
basename = infile;
std::size_t found = basename.rfind(".yaml");
if (found > 0) basename = basename.substr(0,found);
if (found > 0) basename = basename.substr(0, found);
found = basename.find_last_of("/\\");
if (found != std::string::npos) basename = basename.substr(found+1);
if (found != std::string::npos) basename = basename.substr(found + 1);
FILE *fp = fopen(infile.c_str(),"r");
FILE *fp = fopen(infile.c_str(), "r");
yaml_parser_t parser;
yaml_event_t event;
if (!fp) {
std::cerr << "Cannot open yaml file '" << infile
<< "': " << strerror(errno) << std::endl;
std::cerr << "Cannot open yaml file '" << infile << "': " << strerror(errno)
<< std::endl;
return 1;
}
yaml_parser_initialize(&parser);
@ -75,9 +76,9 @@ public:
}
if (accepted) {
if(!consume_key_value(key, event)) {
std::cerr << "Ignoring unknown key/value pair: " << key
<< " = " << event.data.scalar.value << std::endl;
if (!consume_key_value(key, event)) {
std::cerr << "Ignoring unknown key/value pair: " << key << " = "
<< event.data.scalar.value << std::endl;
}
}
yaml_event_delete(&event);
@ -89,13 +90,14 @@ public:
}
protected:
bool consume_key_value(const std::string & key, const yaml_event_t & event) {
auto it = consumers.find(key);
ConsumerClass *consumer = dynamic_cast<ConsumerClass*>(this);
bool consume_key_value(const std::string &key, const yaml_event_t &event)
{
auto it = consumers.find(key);
ConsumerClass *consumer = dynamic_cast<ConsumerClass *>(this);
if(consumer) {
if(it != consumers.end()) {
//std::cerr << "Loading: " << key << std::endl;
if (consumer) {
if (it != consumers.end()) {
// std::cerr << "Loading: " << key << std::endl;
(consumer->*(it->second))(event);
return true;
}
@ -106,69 +108,68 @@ protected:
return false;
}
bool consume_event(yaml_event_t & event) {
bool consume_event(yaml_event_t &event)
{
accepted = false;
switch (state) {
case START:
switch (event.type) {
case YAML_MAPPING_START_EVENT:
state = ACCEPT_KEY;
break;
case YAML_SCALAR_EVENT:
case YAML_SEQUENCE_START_EVENT:
state = ERROR;
break;
case YAML_STREAM_END_EVENT:
state = STOP;
break;
case YAML_STREAM_START_EVENT:
case YAML_DOCUMENT_START_EVENT:
case YAML_DOCUMENT_END_EVENT:
// ignore
break;
default:
std::cerr << "UNHANDLED YAML EVENT: " << event.type << std::endl;
state = ERROR;
break;
}
break;
case START:
switch (event.type) {
case YAML_MAPPING_START_EVENT:
state = ACCEPT_KEY;
break;
case YAML_SCALAR_EVENT:
case YAML_SEQUENCE_START_EVENT:
state = ERROR;
break;
case YAML_STREAM_END_EVENT:
state = STOP;
break;
case YAML_STREAM_START_EVENT:
case YAML_DOCUMENT_START_EVENT:
case YAML_DOCUMENT_END_EVENT:
// ignore
break;
default:
std::cerr << "UNHANDLED YAML EVENT: " << event.type << std::endl;
state = ERROR;
break;
}
break;
case ACCEPT_KEY:
switch (event.type) {
case YAML_SCALAR_EVENT:
key = (char *) event.data.scalar.value;
state = ACCEPT_VALUE;
break;
case YAML_MAPPING_END_EVENT:
state = STOP;
break;
default:
std::cerr << "UNHANDLED YAML EVENT (key): " << event.type
<< "\nVALUE: " << event.data.scalar.value
<< std::endl;
state = ERROR;
break;
}
break;
case ACCEPT_KEY:
switch (event.type) {
case YAML_SCALAR_EVENT:
key = (char *)event.data.scalar.value;
state = ACCEPT_VALUE;
break;
case YAML_MAPPING_END_EVENT:
state = STOP;
break;
default:
std::cerr << "UNHANDLED YAML EVENT (key): " << event.type
<< "\nVALUE: " << event.data.scalar.value << std::endl;
state = ERROR;
break;
}
break;
case ACCEPT_VALUE:
switch (event.type) {
case YAML_SCALAR_EVENT:
accepted = true;
state = ACCEPT_KEY;
break;
default:
std::cerr << "UNHANDLED YAML EVENT (value): " << event.type
<< "\nVALUE: " << event.data.scalar.value
<< std::endl;
state = ERROR;
break;
}
break;
case ACCEPT_VALUE:
switch (event.type) {
case YAML_SCALAR_EVENT:
accepted = true;
state = ACCEPT_KEY;
break;
default:
std::cerr << "UNHANDLED YAML EVENT (value): " << event.type
<< "\nVALUE: " << event.data.scalar.value << std::endl;
state = ERROR;
break;
}
break;
case ERROR:
case STOP:
break;
case ERROR:
case STOP:
break;
}
return (state != ERROR);
}

94
unittest/force-styles/yaml_writer.cpp
View File

@ -14,10 +14,11 @@
#include "yaml_writer.h"
#include "yaml.h"
#include <string>
#include <cstdio>
#include <string>
YamlWriter::YamlWriter(const char * outfile) {
YamlWriter::YamlWriter(const char *outfile)
{
yaml_emitter_initialize(&emitter);
fp = fopen(outfile, "w");
if (!fp) {
@ -31,13 +32,13 @@ YamlWriter::YamlWriter(const char * outfile) {
yaml_emitter_emit(&emitter, &event);
yaml_document_start_event_initialize(&event, NULL, NULL, NULL, 0);
yaml_emitter_emit(&emitter, &event);
yaml_mapping_start_event_initialize(&event, NULL,
(yaml_char_t *)YAML_MAP_TAG,
1, YAML_ANY_MAPPING_STYLE);
yaml_mapping_start_event_initialize(&event, NULL, (yaml_char_t *)YAML_MAP_TAG, 1,
YAML_ANY_MAPPING_STYLE);
yaml_emitter_emit(&emitter, &event);
}
YamlWriter::~YamlWriter() {
YamlWriter::~YamlWriter()
{
yaml_mapping_end_event_initialize(&event);
yaml_emitter_emit(&emitter, &event);
yaml_document_end_event_initialize(&event, 0);
@ -48,84 +49,65 @@ YamlWriter::~YamlWriter() {
fclose(fp);
}
void YamlWriter::emit(const std::string &key, const double value) {
yaml_scalar_event_initialize(&event, NULL,
(yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *) key.c_str(),
key.size(), 1, 0,
void YamlWriter::emit(const std::string &key, const double value)
{
yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *)key.c_str(), key.size(), 1, 0,
YAML_PLAIN_SCALAR_STYLE);
yaml_emitter_emit(&emitter, &event);
char buf[256];
snprintf(buf,256,"%.15g",value);
yaml_scalar_event_initialize(&event, NULL,
(yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *)buf,
strlen(buf), 1, 0,
YAML_PLAIN_SCALAR_STYLE);
snprintf(buf, 256, "%.15g", value);
yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG, (yaml_char_t *)buf,
strlen(buf), 1, 0, YAML_PLAIN_SCALAR_STYLE);
yaml_emitter_emit(&emitter, &event);
}
void YamlWriter::emit(const std::string &key, const long value) {
yaml_scalar_event_initialize(&event, NULL,
(yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *) key.c_str(),
key.size(), 1, 0,
void YamlWriter::emit(const std::string &key, const long value)
{
yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *)key.c_str(), key.size(), 1, 0,
YAML_PLAIN_SCALAR_STYLE);
yaml_emitter_emit(&emitter, &event);
char buf[256];
snprintf(buf,256,"%ld",value);
yaml_scalar_event_initialize(&event, NULL,
(yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *)buf,
strlen(buf), 1, 0,
YAML_PLAIN_SCALAR_STYLE);
snprintf(buf, 256, "%ld", value);
yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG, (yaml_char_t *)buf,
strlen(buf), 1, 0, YAML_PLAIN_SCALAR_STYLE);
yaml_emitter_emit(&emitter, &event);
}
void YamlWriter::emit(const std::string &key, const int value) {
yaml_scalar_event_initialize(&event, NULL,
(yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *) key.c_str(),
key.size(), 1, 0,
void YamlWriter::emit(const std::string &key, const int value)
{
yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *)key.c_str(), key.size(), 1, 0,
YAML_PLAIN_SCALAR_STYLE);
yaml_emitter_emit(&emitter, &event);
char buf[256];
snprintf(buf,256,"%d",value);
yaml_scalar_event_initialize(&event, NULL,
(yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *)buf,
strlen(buf), 1, 0,
YAML_PLAIN_SCALAR_STYLE);
snprintf(buf, 256, "%d", value);
yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG, (yaml_char_t *)buf,
strlen(buf), 1, 0, YAML_PLAIN_SCALAR_STYLE);
yaml_emitter_emit(&emitter, &event);
}
void YamlWriter::emit(const std::string &key, const std::string &value)
{
yaml_scalar_event_initialize(&event, NULL,
(yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *) key.c_str(),
key.size(), 1, 0,
yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *)key.c_str(), key.size(), 1, 0,
YAML_PLAIN_SCALAR_STYLE);
yaml_emitter_emit(&emitter, &event);
yaml_scalar_event_initialize(&event, NULL,
(yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *)value.c_str(),
value.size(), 1, 0,
yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *)value.c_str(), value.size(), 1, 0,
YAML_PLAIN_SCALAR_STYLE);
yaml_emitter_emit(&emitter, &event);
}
void YamlWriter::emit_block(const std::string &key, const std::string &value) {
yaml_scalar_event_initialize(&event, NULL,
(yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *) key.c_str(),
key.size(), 1, 0,
void YamlWriter::emit_block(const std::string &key, const std::string &value)
{
yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *)key.c_str(), key.size(), 1, 0,
YAML_PLAIN_SCALAR_STYLE);
yaml_emitter_emit(&emitter, &event);
yaml_scalar_event_initialize(&event, NULL,
(yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *)value.c_str(),
value.size(), 1, 0,
yaml_scalar_event_initialize(&event, NULL, (yaml_char_t *)YAML_STR_TAG,
(yaml_char_t *)value.c_str(), value.size(), 1, 0,
YAML_LITERAL_SCALAR_STYLE);
yaml_emitter_emit(&emitter, &event);
}

8
unittest/force-styles/yaml_writer.h
View File

@ -20,7 +20,7 @@
class YamlWriter {
public:
YamlWriter(const char * outfile);
YamlWriter(const char *outfile);
virtual ~YamlWriter();
// emitters
@ -33,11 +33,11 @@ public:
private:
FILE *fp;
yaml_emitter_t emitter;
yaml_event_t event;
yaml_event_t event;
private:
YamlWriter() {};
YamlWriter(const YamlWriter &) {};
YamlWriter(){};
YamlWriter(const YamlWriter &){};
};
#endif

120
unittest/formats/test_eim_potential_file_reader.cpp
View File

@ -11,11 +11,11 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "MANYBODY/pair_eim.h"
#include "lammps.h"
#include "utils.h"
#include "MANYBODY/pair_eim.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <mpi.h>
@ -23,64 +23,67 @@ using namespace LAMMPS_NS;
class EIMPotentialFileReaderTest : public ::testing::Test {
protected:
LAMMPS * lmp;
LAMMPS *lmp;
PairEIM::Setfl setfl;
static const int nelements = 9;
void SetUp() override {
const char *args[] = {"PotentialFileReaderTest", "-log", "none", "-echo", "screen", "-nocite" };
void SetUp() override
{
const char *args[] = {
"PotentialFileReaderTest", "-log", "none", "-echo", "screen", "-nocite"};
char **argv = (char **)args;
int argc = sizeof(args)/sizeof(char *);
int argc = sizeof(args) / sizeof(char *);
::testing::internal::CaptureStdout();
lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD);
::testing::internal::GetCapturedStdout();
int npair = nelements*(nelements+1)/2;
setfl.ielement = new int[nelements];
setfl.mass = new double[nelements];
int npair = nelements * (nelements + 1) / 2;
setfl.ielement = new int[nelements];
setfl.mass = new double[nelements];
setfl.negativity = new double[nelements];
setfl.ra = new double[nelements];
setfl.ri = new double[nelements];
setfl.Ec = new double[nelements];
setfl.q0 = new double[nelements];
setfl.rcutphiA = new double[npair];
setfl.rcutphiR = new double[npair];
setfl.Eb = new double[npair];
setfl.r0 = new double[npair];
setfl.alpha = new double[npair];
setfl.beta = new double[npair];
setfl.rcutq = new double[npair];
setfl.Asigma = new double[npair];
setfl.rq = new double[npair];
setfl.rcutsigma = new double[npair];
setfl.Ac = new double[npair];
setfl.zeta = new double[npair];
setfl.rs = new double[npair];
setfl.tp = new int[npair];
setfl.ra = new double[nelements];
setfl.ri = new double[nelements];
setfl.Ec = new double[nelements];
setfl.q0 = new double[nelements];
setfl.rcutphiA = new double[npair];
setfl.rcutphiR = new double[npair];
setfl.Eb = new double[npair];
setfl.r0 = new double[npair];
setfl.alpha = new double[npair];
setfl.beta = new double[npair];
setfl.rcutq = new double[npair];
setfl.Asigma = new double[npair];
setfl.rq = new double[npair];
setfl.rcutsigma = new double[npair];
setfl.Ac = new double[npair];
setfl.zeta = new double[npair];
setfl.rs = new double[npair];
setfl.tp = new int[npair];
}
void TearDown() override {
delete [] setfl.ielement;
delete [] setfl.mass;
delete [] setfl.negativity;
delete [] setfl.ra;
delete [] setfl.ri;
delete [] setfl.Ec;
delete [] setfl.q0;
delete [] setfl.rcutphiA;
delete [] setfl.rcutphiR;
delete [] setfl.Eb;
delete [] setfl.r0;
delete [] setfl.alpha;
delete [] setfl.beta;
delete [] setfl.rcutq;
delete [] setfl.Asigma;
delete [] setfl.rq;
delete [] setfl.rcutsigma;
delete [] setfl.Ac;
delete [] setfl.zeta;
delete [] setfl.rs;
delete [] setfl.tp;
void TearDown() override
{
delete[] setfl.ielement;
delete[] setfl.mass;
delete[] setfl.negativity;
delete[] setfl.ra;
delete[] setfl.ri;
delete[] setfl.Ec;
delete[] setfl.q0;
delete[] setfl.rcutphiA;
delete[] setfl.rcutphiR;
delete[] setfl.Eb;
delete[] setfl.r0;
delete[] setfl.alpha;
delete[] setfl.beta;
delete[] setfl.rcutq;
delete[] setfl.Asigma;
delete[] setfl.rq;
delete[] setfl.rcutsigma;
delete[] setfl.Ac;
delete[] setfl.zeta;
delete[] setfl.rs;
delete[] setfl.tp;
::testing::internal::CaptureStdout();
delete lmp;
@ -88,7 +91,8 @@ protected:
}
};
TEST_F(EIMPotentialFileReaderTest, global_line) {
TEST_F(EIMPotentialFileReaderTest, global_line)
{
::testing::internal::CaptureStdout();
EIMPotentialFileReader reader(lmp, "ffield.eim");
::testing::internal::GetCapturedStdout();
@ -99,7 +103,8 @@ TEST_F(EIMPotentialFileReaderTest, global_line) {
ASSERT_DOUBLE_EQ(setfl.rsmall, 1.645);
}
TEST_F(EIMPotentialFileReaderTest, element_line_sequential) {
TEST_F(EIMPotentialFileReaderTest, element_line_sequential)
{
::testing::internal::CaptureStdout();
EIMPotentialFileReader reader(lmp, "ffield.eim");
::testing::internal::GetCapturedStdout();
@ -123,7 +128,8 @@ TEST_F(EIMPotentialFileReaderTest, element_line_sequential) {
ASSERT_DOUBLE_EQ(setfl.q0[1], 0.0000e+00);
}
TEST_F(EIMPotentialFileReaderTest, element_line_random) {
TEST_F(EIMPotentialFileReaderTest, element_line_random)
{
::testing::internal::CaptureStdout();
EIMPotentialFileReader reader(lmp, "ffield.eim");
::testing::internal::GetCapturedStdout();
@ -138,7 +144,8 @@ TEST_F(EIMPotentialFileReaderTest, element_line_random) {
ASSERT_DOUBLE_EQ(setfl.q0[0], 0.0000e+00);
}
TEST_F(EIMPotentialFileReaderTest, pair_line) {
TEST_F(EIMPotentialFileReaderTest, pair_line)
{
::testing::internal::CaptureStdout();
EIMPotentialFileReader reader(lmp, "ffield.eim");
::testing::internal::GetCapturedStdout();
@ -147,7 +154,7 @@ TEST_F(EIMPotentialFileReaderTest, pair_line) {
ASSERT_DOUBLE_EQ(setfl.rcutphiA[0], 6.0490e+00);
ASSERT_DOUBLE_EQ(setfl.rcutphiR[0], 6.0490e+00);
ASSERT_DOUBLE_EQ(setfl.Eb[0], -2.5330e-01);
ASSERT_DOUBLE_EQ(setfl.r0[0], 3.6176e+00);
ASSERT_DOUBLE_EQ(setfl.r0[0], 3.6176e+00);
ASSERT_DOUBLE_EQ(setfl.alpha[0], 7.5536e+00);
ASSERT_DOUBLE_EQ(setfl.beta[0], 3.5017e+00);
ASSERT_DOUBLE_EQ(setfl.rcutq[0], 0.0000e+00);
@ -160,7 +167,8 @@ TEST_F(EIMPotentialFileReaderTest, pair_line) {
ASSERT_EQ(setfl.tp[0], 1);
}
TEST_F(EIMPotentialFileReaderTest, pair_identical) {
TEST_F(EIMPotentialFileReaderTest, pair_identical)
{
::testing::internal::CaptureStdout();
EIMPotentialFileReader reader(lmp, "ffield.eim");
::testing::internal::GetCapturedStdout();

66
unittest/formats/test_potential_file_reader.cpp
View File

@ -11,23 +11,23 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "potential_file_reader.h"
#include "lammps.h"
#include "utils.h"
#include "MANYBODY/pair_sw.h"
#include "MANYBODY/pair_comb.h"
#include "MANYBODY/pair_comb3.h"
#include "MANYBODY/pair_eim.h"
#include "MANYBODY/pair_gw.h"
#include "MANYBODY/pair_gw_zbl.h"
#include "MANYBODY/pair_nb3b_harmonic.h"
#include "MANYBODY/pair_sw.h"
#include "MANYBODY/pair_tersoff.h"
#include "MANYBODY/pair_tersoff_mod.h"
#include "MANYBODY/pair_tersoff_mod_c.h"
#include "MANYBODY/pair_tersoff_zbl.h"
#include "MANYBODY/pair_gw.h"
#include "MANYBODY/pair_gw_zbl.h"
#include "MANYBODY/pair_nb3b_harmonic.h"
#include "MANYBODY/pair_vashishta.h"
#include "MANYBODY/pair_eim.h"
#include "lammps.h"
#include "potential_file_reader.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <mpi.h>
@ -47,25 +47,29 @@ const int LAMMPS_NS::PairVashishta::NPARAMS_PER_LINE;
class PotentialFileReaderTest : public ::testing::Test {
protected:
LAMMPS * lmp;
LAMMPS *lmp;
void SetUp() override {
const char *args[] = {"PotentialFileReaderTest", "-log", "none", "-echo", "screen", "-nocite" };
void SetUp() override
{
const char *args[] = {
"PotentialFileReaderTest", "-log", "none", "-echo", "screen", "-nocite"};
char **argv = (char **)args;
int argc = sizeof(args)/sizeof(char *);
int argc = sizeof(args) / sizeof(char *);
::testing::internal::CaptureStdout();
lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD);
::testing::internal::GetCapturedStdout();
}
void TearDown() override {
void TearDown() override
{
::testing::internal::CaptureStdout();
delete lmp;
::testing::internal::GetCapturedStdout();
}
};
TEST_F(PotentialFileReaderTest, Si) {
TEST_F(PotentialFileReaderTest, Si)
{
::testing::internal::CaptureStdout();
PotentialFileReader reader(lmp, "Si.sw", "Stillinger-Weber");
::testing::internal::GetCapturedStdout();
@ -74,7 +78,8 @@ TEST_F(PotentialFileReaderTest, Si) {
ASSERT_EQ(utils::count_words(line), PairSW::NPARAMS_PER_LINE);
}
TEST_F(PotentialFileReaderTest, Comb) {
TEST_F(PotentialFileReaderTest, Comb)
{
::testing::internal::CaptureStdout();
PotentialFileReader reader(lmp, "ffield.comb", "COMB");
::testing::internal::GetCapturedStdout();
@ -83,7 +88,8 @@ TEST_F(PotentialFileReaderTest, Comb) {
ASSERT_EQ(utils::count_words(line), PairComb::NPARAMS_PER_LINE);
}
TEST_F(PotentialFileReaderTest, Comb3) {
TEST_F(PotentialFileReaderTest, Comb3)
{
::testing::internal::CaptureStdout();
PotentialFileReader reader(lmp, "ffield.comb3", "COMB3");
::testing::internal::GetCapturedStdout();
@ -92,7 +98,8 @@ TEST_F(PotentialFileReaderTest, Comb3) {
ASSERT_EQ(utils::count_words(line), PairComb3::NPARAMS_PER_LINE);
}
TEST_F(PotentialFileReaderTest, Tersoff) {
TEST_F(PotentialFileReaderTest, Tersoff)
{
::testing::internal::CaptureStdout();
PotentialFileReader reader(lmp, "Si.tersoff", "Tersoff");
::testing::internal::GetCapturedStdout();
@ -101,7 +108,8 @@ TEST_F(PotentialFileReaderTest, Tersoff) {
ASSERT_EQ(utils::count_words(line), PairTersoff::NPARAMS_PER_LINE);
}
TEST_F(PotentialFileReaderTest, TersoffMod) {
TEST_F(PotentialFileReaderTest, TersoffMod)
{
::testing::internal::CaptureStdout();
PotentialFileReader reader(lmp, "Si.tersoff.mod", "Tersoff/Mod");
::testing::internal::GetCapturedStdout();
@ -110,7 +118,8 @@ TEST_F(PotentialFileReaderTest, TersoffMod) {
ASSERT_EQ(utils::count_words(line), PairTersoffMOD::NPARAMS_PER_LINE);
}
TEST_F(PotentialFileReaderTest, TersoffModC) {
TEST_F(PotentialFileReaderTest, TersoffModC)
{
::testing::internal::CaptureStdout();
PotentialFileReader reader(lmp, "Si.tersoff.modc", "Tersoff/ModC");
::testing::internal::GetCapturedStdout();
@ -119,7 +128,8 @@ TEST_F(PotentialFileReaderTest, TersoffModC) {
ASSERT_EQ(utils::count_words(line), PairTersoffMODC::NPARAMS_PER_LINE);
}
TEST_F(PotentialFileReaderTest, TersoffZBL) {
TEST_F(PotentialFileReaderTest, TersoffZBL)
{
::testing::internal::CaptureStdout();
PotentialFileReader reader(lmp, "SiC.tersoff.zbl", "Tersoff/ZBL");
::testing::internal::GetCapturedStdout();
@ -128,7 +138,8 @@ TEST_F(PotentialFileReaderTest, TersoffZBL) {
ASSERT_EQ(utils::count_words(line), PairTersoffZBL::NPARAMS_PER_LINE);
}
TEST_F(PotentialFileReaderTest, GW) {
TEST_F(PotentialFileReaderTest, GW)
{
::testing::internal::CaptureStdout();
PotentialFileReader reader(lmp, "SiC.gw", "GW");
::testing::internal::GetCapturedStdout();
@ -137,7 +148,8 @@ TEST_F(PotentialFileReaderTest, GW) {
ASSERT_EQ(utils::count_words(line), PairGW::NPARAMS_PER_LINE);
}
TEST_F(PotentialFileReaderTest, GWZBL) {
TEST_F(PotentialFileReaderTest, GWZBL)
{
::testing::internal::CaptureStdout();
PotentialFileReader reader(lmp, "SiC.gw.zbl", "GW/ZBL");
::testing::internal::GetCapturedStdout();
@ -146,7 +158,8 @@ TEST_F(PotentialFileReaderTest, GWZBL) {
ASSERT_EQ(utils::count_words(line), PairGWZBL::NPARAMS_PER_LINE);
}
TEST_F(PotentialFileReaderTest, Nb3bHarmonic) {
TEST_F(PotentialFileReaderTest, Nb3bHarmonic)
{
::testing::internal::CaptureStdout();
PotentialFileReader reader(lmp, "MOH.nb3b.harmonic", "NB3B Harmonic");
::testing::internal::GetCapturedStdout();
@ -155,7 +168,8 @@ TEST_F(PotentialFileReaderTest, Nb3bHarmonic) {
ASSERT_EQ(utils::count_words(line), PairNb3bHarmonic::NPARAMS_PER_LINE);
}
TEST_F(PotentialFileReaderTest, Vashishta) {
TEST_F(PotentialFileReaderTest, Vashishta)
{
::testing::internal::CaptureStdout();
PotentialFileReader reader(lmp, "SiC.vashishta", "Vashishta");
::testing::internal::GetCapturedStdout();

73
unittest/utils/test_fmtlib.cpp
View File

@ -11,114 +11,127 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "lmptype.h"
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "fmt/format.h"
#include <string>
#include "lmptype.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <exception>
#include <string>
using namespace LAMMPS_NS;
using ::testing::Eq;
// this tests a subset of {fmt} that is most relevant to LAMMPS
TEST(FmtLib, insert_string) {
TEST(FmtLib, insert_string)
{
const char val[] = "word";
auto text = fmt::format("word {}",val);
auto text = fmt::format("word {}", val);
ASSERT_THAT(text, Eq("word word"));
}
TEST(FmtLib, insert_int) {
TEST(FmtLib, insert_int)
{
const int val = 333;
auto text = fmt::format("word {}",val);
auto text = fmt::format("word {}", val);
ASSERT_THAT(text, Eq("word 333"));
}
TEST(FmtLib, insert_neg_int) {
TEST(FmtLib, insert_neg_int)
{
const int val = -333;
auto text = fmt::format("word {}",val);
auto text = fmt::format("word {}", val);
ASSERT_THAT(text, Eq("word -333"));
}
TEST(FmtLib, insert_bigint) {
TEST(FmtLib, insert_bigint)
{
#if defined(LAMMPS_BIGBIG) || defined(LAMMPS_SMALLBIG)
const bigint val = 9945234592L;
auto text = fmt::format("word {}",val);
auto text = fmt::format("word {}", val);
ASSERT_THAT(text, Eq("word 9945234592"));
#else
GTEST_SKIP();
#endif
}
TEST(FmtLib, insert_neg_bigint) {
TEST(FmtLib, insert_neg_bigint)
{
#if defined(LAMMPS_BIGBIG) || defined(LAMMPS_SMALLBIG)
const bigint val = -9945234592L;
auto text = fmt::format("word {}",val);
auto text = fmt::format("word {}", val);
ASSERT_THAT(text, Eq("word -9945234592"));
#else
GTEST_SKIP();
#endif
}
TEST(FmtLib, insert_tagint) {
TEST(FmtLib, insert_tagint)
{
#if defined(LAMMPS_BIGBIG)
const tagint val = 9945234592L;
auto text = fmt::format("word {}",val);
auto text = fmt::format("word {}", val);
ASSERT_THAT(text, Eq("word 9945234592"));
#else
GTEST_SKIP();
#endif
}
TEST(FmtLib, insert_neg_tagint) {
TEST(FmtLib, insert_neg_tagint)
{
#if defined(LAMMPS_BIGBIG)
const tagint val = -9945234592L;
auto text = fmt::format("word {}",val);
auto text = fmt::format("word {}", val);
ASSERT_THAT(text, Eq("word -9945234592"));
#else
GTEST_SKIP();
#endif
}
TEST(FmtLib, insert_imageint) {
TEST(FmtLib, insert_imageint)
{
#if defined(LAMMPS_BIGBIG)
const imageint val = 9945234592L;
auto text = fmt::format("word {}",val);
auto text = fmt::format("word {}", val);
ASSERT_THAT(text, Eq("word 9945234592"));
#else
GTEST_SKIP();
#endif
}
TEST(FmtLib, insert_neg_imageint) {
TEST(FmtLib, insert_neg_imageint)
{
#if defined(LAMMPS_BIGBIG)
const imageint val = -9945234592L;
auto text = fmt::format("word {}",val);
auto text = fmt::format("word {}", val);
ASSERT_THAT(text, Eq("word -9945234592"));
#else
GTEST_SKIP();
#endif
}
TEST(FmtLib, insert_double) {
TEST(FmtLib, insert_double)
{
const double val = 1.5;
auto text = fmt::format("word {}",val);
auto text = fmt::format("word {}", val);
ASSERT_THAT(text, Eq("word 1.5"));
}
TEST(FmtLib, insert_neg_double) {
TEST(FmtLib, insert_neg_double)
{
const double val = -1.5;
auto text = fmt::format("word {}",val);
auto text = fmt::format("word {}", val);
ASSERT_THAT(text, Eq("word -1.5"));
}
TEST(FmtLib, int_for_double) {
TEST(FmtLib, int_for_double)
{
const double val = -1.5;
ASSERT_THROW(fmt::format("word {:d}",val),std::exception);
ASSERT_THROW(fmt::format("word {:d}", val), std::exception);
}
TEST(FmtLib, double_for_int) {
TEST(FmtLib, double_for_int)
{
const int val = 15;
ASSERT_THROW(fmt::format("word {:g}",val),std::exception);
ASSERT_THROW(fmt::format("word {:g}", val), std::exception);
}

55
unittest/utils/test_tokenizer.cpp
View File

@ -11,100 +11,117 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "tokenizer.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
using namespace LAMMPS_NS;
using ::testing::Eq;
TEST(Tokenizer, empty_string) {
TEST(Tokenizer, empty_string)
{
Tokenizer t("", " ");
ASSERT_EQ(t.count(), 0);
}
TEST(Tokenizer, whitespace_only) {
TEST(Tokenizer, whitespace_only)
{
Tokenizer t(" ", " ");
ASSERT_EQ(t.count(), 0);
}
TEST(Tokenizer, single_word) {
TEST(Tokenizer, single_word)
{
Tokenizer t("test", " ");
ASSERT_EQ(t.count(), 1);
}
TEST(Tokenizer, two_words) {
TEST(Tokenizer, two_words)
{
Tokenizer t("test word", " ");
ASSERT_EQ(t.count(), 2);
}
TEST(Tokenizer, prefix_separators) {
TEST(Tokenizer, prefix_separators)
{
Tokenizer t(" test word", " ");
ASSERT_EQ(t.count(), 2);
}
TEST(Tokenizer, postfix_separators) {
TEST(Tokenizer, postfix_separators)
{
Tokenizer t("test word ", " ");
ASSERT_EQ(t.count(), 2);
}
TEST(Tokenizer, iterate_words) {
TEST(Tokenizer, iterate_words)
{
Tokenizer t(" test word ", " ");
ASSERT_THAT(t.next(), Eq("test"));
ASSERT_THAT(t.next(), Eq("word"));
ASSERT_EQ(t.count(), 2);
}
TEST(Tokenizer, default_separators) {
TEST(Tokenizer, default_separators)
{
Tokenizer t(" \r\n test \t word \f");
ASSERT_THAT(t.next(), Eq("test"));
ASSERT_THAT(t.next(), Eq("word"));
ASSERT_EQ(t.count(), 2);
}
TEST(Tokenizer, as_vector) {
TEST(Tokenizer, as_vector)
{
Tokenizer t(" \r\n test \t word \f");
std::vector<std::string> list = t.as_vector();
ASSERT_THAT(list[0], Eq("test"));
ASSERT_THAT(list[1], Eq("word"));
}
TEST(ValueTokenizer, empty_string) {
TEST(ValueTokenizer, empty_string)
{
ValueTokenizer values("");
ASSERT_FALSE(values.has_next());
}
TEST(ValueTokenizer, bad_integer) {
TEST(ValueTokenizer, bad_integer)
{
ValueTokenizer values("f10");
ASSERT_THROW(values.next_int(), InvalidIntegerException);
}
TEST(ValueTokenizer, bad_double) {
TEST(ValueTokenizer, bad_double)
{
ValueTokenizer values("1a.0");
ASSERT_THROW(values.next_double(), InvalidFloatException);
}
TEST(ValueTokenizer, valid_int) {
TEST(ValueTokenizer, valid_int)
{
ValueTokenizer values("10");
ASSERT_EQ(values.next_int(), 10);
}
TEST(ValueTokenizer, valid_tagint) {
TEST(ValueTokenizer, valid_tagint)
{
ValueTokenizer values("42");
ASSERT_EQ(values.next_tagint(), 42);
}
TEST(ValueTokenizer, valid_bigint) {
TEST(ValueTokenizer, valid_bigint)
{
ValueTokenizer values("42");
ASSERT_EQ(values.next_bigint(), 42);
}
TEST(ValueTokenizer, valid_double) {
TEST(ValueTokenizer, valid_double)
{
ValueTokenizer values("3.14");
ASSERT_DOUBLE_EQ(values.next_double(), 3.14);
}
TEST(ValueTokenizer, valid_double_with_exponential) {
TEST(ValueTokenizer, valid_double_with_exponential)
{
ValueTokenizer values("3.14e22");
ASSERT_DOUBLE_EQ(values.next_double(), 3.14e22);
}

222
unittest/utils/test_utils.cpp
View File

@ -11,215 +11,265 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "utils.h"
#include <string>
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <cerrno>
#include <cstdio>
#include <cstdlib>
#include <string>
using namespace LAMMPS_NS;
using ::testing::Eq;
TEST(Utils, trim_comment) {
TEST(Utils, trim_comment)
{
auto trimmed = utils::trim_comment("some text # comment");
ASSERT_THAT(trimmed, Eq("some text "));
}
TEST(Utils, count_words) {
TEST(Utils, count_words)
{
ASSERT_EQ(utils::count_words("some text # comment"), 4);
}
TEST(Utils, count_words_non_default) {
TEST(Utils, count_words_non_default)
{
ASSERT_EQ(utils::count_words("some text # comment", " #"), 3);
}
TEST(Utils, trim_and_count_words) {
TEST(Utils, trim_and_count_words)
{
ASSERT_EQ(utils::trim_and_count_words("some text # comment"), 2);
}
TEST(Utils, count_words_with_extra_spaces) {
TEST(Utils, count_words_with_extra_spaces)
{
ASSERT_EQ(utils::count_words(" some text # comment "), 4);
}
TEST(Utils, valid_integer1) {
TEST(Utils, valid_integer1)
{
ASSERT_TRUE(utils::is_integer("10"));
}
TEST(Utils, valid_integer2) {
TEST(Utils, valid_integer2)
{
ASSERT_TRUE(utils::is_integer("-10"));
}
TEST(Utils, valid_integer3) {
TEST(Utils, valid_integer3)
{
ASSERT_TRUE(utils::is_integer("+10"));
}
TEST(Utils, valid_double1) {
TEST(Utils, valid_double1)
{
ASSERT_TRUE(utils::is_double("10.0"));
}
TEST(Utils, valid_double2) {
TEST(Utils, valid_double2)
{
ASSERT_TRUE(utils::is_double("1."));
}
TEST(Utils, valid_double3) {
TEST(Utils, valid_double3)
{
ASSERT_TRUE(utils::is_double(".0"));
}
TEST(Utils, valid_double4) {
TEST(Utils, valid_double4)
{
ASSERT_TRUE(utils::is_double("-10.0"));
}
TEST(Utils, valid_double5) {
TEST(Utils, valid_double5)
{
ASSERT_TRUE(utils::is_double("-1."));
}
TEST(Utils, valid_double6) {
TEST(Utils, valid_double6)
{
ASSERT_TRUE(utils::is_double("-.0"));
}
TEST(Utils, valid_double7) {
TEST(Utils, valid_double7)
{
ASSERT_TRUE(utils::is_double("+10.0"));
}
TEST(Utils, valid_double8) {
TEST(Utils, valid_double8)
{
ASSERT_TRUE(utils::is_double("+1."));
}
TEST(Utils, valid_double9) {
TEST(Utils, valid_double9)
{
ASSERT_TRUE(utils::is_double("+.0"));
}
TEST(Utils, empty_not_an_integer) {
TEST(Utils, empty_not_an_integer)
{
ASSERT_FALSE(utils::is_integer(""));
}
TEST(Utils, empty_not_a_double) {
TEST(Utils, empty_not_a_double)
{
ASSERT_FALSE(utils::is_double(""));
}
TEST(Utils, text_not_an_integer) {
TEST(Utils, text_not_an_integer)
{
ASSERT_FALSE(utils::is_integer("one"));
}
TEST(Utils, text_not_a_double) {
TEST(Utils, text_not_a_double)
{
ASSERT_FALSE(utils::is_double("half"));
}
TEST(Utils, double_not_an_integer1) {
TEST(Utils, double_not_an_integer1)
{
ASSERT_FALSE(utils::is_integer("10.0"));
}
TEST(Utils, double_not_an_integer2) {
TEST(Utils, double_not_an_integer2)
{
ASSERT_FALSE(utils::is_integer(".0"));
}
TEST(Utils, double_not_an_integer3) {
TEST(Utils, double_not_an_integer3)
{
ASSERT_FALSE(utils::is_integer("1."));
}
TEST(Utils, integer_is_double1) {
TEST(Utils, integer_is_double1)
{
ASSERT_TRUE(utils::is_double("10"));
}
TEST(Utils, integer_is_double2) {
TEST(Utils, integer_is_double2)
{
ASSERT_TRUE(utils::is_double("-10"));
}
TEST(Utils, is_double_with_exponential) {
TEST(Utils, is_double_with_exponential)
{
ASSERT_TRUE(utils::is_double("+1e02"));
}
TEST(Utils, is_double_with_neg_exponential) {
TEST(Utils, is_double_with_neg_exponential)
{
ASSERT_TRUE(utils::is_double("1.0e-22"));
}
TEST(Utils, is_double_with_pos_exponential) {
TEST(Utils, is_double_with_pos_exponential)
{
ASSERT_TRUE(utils::is_double(".1e+22"));
}
TEST(Utils, signed_double_and_exponential) {
TEST(Utils, signed_double_and_exponential)
{
ASSERT_TRUE(utils::is_double("-10E-22"));
}
TEST(Utils, is_double_with_d_exponential) {
TEST(Utils, is_double_with_d_exponential)
{
ASSERT_FALSE(utils::is_double("10d22"));
}
TEST(Utils, is_double_with_neg_d_exponential) {
TEST(Utils, is_double_with_neg_d_exponential)
{
ASSERT_FALSE(utils::is_double("10d-22"));
}
TEST(Utils, signed_double_and_d_exponential) {
TEST(Utils, signed_double_and_d_exponential)
{
ASSERT_FALSE(utils::is_double("-10D-22"));
}
TEST(Utils, strmatch_beg) {
ASSERT_TRUE(utils::strmatch("rigid/small/omp","^rigid"));
TEST(Utils, strmatch_beg)
{
ASSERT_TRUE(utils::strmatch("rigid/small/omp", "^rigid"));
}
TEST(Utils, strmatch_mid1) {
ASSERT_TRUE(utils::strmatch("rigid/small/omp","small"));
TEST(Utils, strmatch_mid1)
{
ASSERT_TRUE(utils::strmatch("rigid/small/omp", "small"));
}
TEST(Utils, strmatch_mid2) {
ASSERT_TRUE(utils::strmatch("rigid/small/omp","omp"));
TEST(Utils, strmatch_mid2)
{
ASSERT_TRUE(utils::strmatch("rigid/small/omp", "omp"));
}
TEST(Utils, strmatch_end) {
ASSERT_TRUE(utils::strmatch("rigid/small/omp","/omp$"));
TEST(Utils, strmatch_end)
{
ASSERT_TRUE(utils::strmatch("rigid/small/omp", "/omp$"));
}
TEST(Utils, no_strmatch_beg) {
ASSERT_FALSE(utils::strmatch("rigid/small/omp","^small"));
TEST(Utils, no_strmatch_beg)
{
ASSERT_FALSE(utils::strmatch("rigid/small/omp", "^small"));
}
TEST(Utils, no_strmatch_mid) {
ASSERT_FALSE(utils::strmatch("rigid/small/omp","none"));
TEST(Utils, no_strmatch_mid)
{
ASSERT_FALSE(utils::strmatch("rigid/small/omp", "none"));
}
TEST(Utils, no_strmatch_end) {
ASSERT_FALSE(utils::strmatch("rigid/small/omp","/opt$"));
TEST(Utils, no_strmatch_end)
{
ASSERT_FALSE(utils::strmatch("rigid/small/omp", "/opt$"));
}
TEST(Utils, strmatch_whole_line) {
ASSERT_TRUE(utils::strmatch("ITEM: UNITS\n","^\\s*ITEM: UNITS\\s*$"));
TEST(Utils, strmatch_whole_line)
{
ASSERT_TRUE(utils::strmatch("ITEM: UNITS\n", "^\\s*ITEM: UNITS\\s*$"));
}
TEST(Utils, no_strmatch_whole_line) {
ASSERT_FALSE(utils::strmatch("ITEM: UNITS\n","^\\s*ITEM: UNIT\\s*$"));
TEST(Utils, no_strmatch_whole_line)
{
ASSERT_FALSE(utils::strmatch("ITEM: UNITS\n", "^\\s*ITEM: UNIT\\s*$"));
}
TEST(Utils, strmatch_integer_in_line) {
ASSERT_TRUE(utils::strmatch(" 5 angles\n","^\\s*\\d+\\s+angles\\s"));
TEST(Utils, strmatch_integer_in_line)
{
ASSERT_TRUE(utils::strmatch(" 5 angles\n", "^\\s*\\d+\\s+angles\\s"));
}
TEST(Utils, strmatch_float_in_line) {
ASSERT_TRUE(utils::strmatch(" 5.0 angles\n","^\\s*\\f+\\s+angles\\s"));
TEST(Utils, strmatch_float_in_line)
{
ASSERT_TRUE(utils::strmatch(" 5.0 angles\n", "^\\s*\\f+\\s+angles\\s"));
}
TEST(Utils, strmatch_int_as_float_in_line) {
ASSERT_TRUE(utils::strmatch(" 5 angles\n","^\\s*\\f+\\s+angles\\s"));
TEST(Utils, strmatch_int_as_float_in_line)
{
ASSERT_TRUE(utils::strmatch(" 5 angles\n", "^\\s*\\f+\\s+angles\\s"));
}
TEST(Utils, strmatch_char_range) {
ASSERT_TRUE(utils::strmatch("rigid","^[ip-s]+gid"));
TEST(Utils, strmatch_char_range)
{
ASSERT_TRUE(utils::strmatch("rigid", "^[ip-s]+gid"));
}
TEST(Utils, strmatch_opt_range) {
ASSERT_TRUE(utils::strmatch("rigid","^[0-9]*[p-s]igid"));
TEST(Utils, strmatch_opt_range)
{
ASSERT_TRUE(utils::strmatch("rigid", "^[0-9]*[p-s]igid"));
}
TEST(Utils, path_join) {
TEST(Utils, path_join)
{
#if defined(_WIN32)
ASSERT_THAT(utils::path_join("c:\\parent\\folder", "filename"), Eq("c:\\parent\\folder\\filename"));
ASSERT_THAT(utils::path_join("c:\\parent\\folder", "filename"),
Eq("c:\\parent\\folder\\filename"));
#else
ASSERT_THAT(utils::path_join("/parent/folder", "filename"), Eq("/parent/folder/filename"));
#endif
}
TEST(Utils, path_basename) {
TEST(Utils, path_basename)
{
#if defined(_WIN32)
ASSERT_THAT(utils::path_basename("c:\\parent\\folder\\filename"), Eq("filename"));
#else
@ -227,9 +277,10 @@ TEST(Utils, path_basename) {
#endif
}
TEST(Utils, getsyserror) {
TEST(Utils, getsyserror)
{
#if defined(__linux__)
errno = ENOENT;
errno = ENOENT;
std::string errmesg = utils::getsyserror();
ASSERT_THAT(errmesg, Eq("No such file or directory"));
#else
@ -237,35 +288,36 @@ TEST(Utils, getsyserror) {
#endif
}
TEST(Utils, potential_file) {
TEST(Utils, potential_file)
{
FILE *fp;
fp = fopen("ctest1.txt","w");
ASSERT_NE(fp,nullptr);
fputs("# DATE: 2020-02-20 CONTRIBUTOR: Nessuno UNITS: real\n",fp);
fp = fopen("ctest1.txt", "w");
ASSERT_NE(fp, nullptr);
fputs("# DATE: 2020-02-20 UNITS: real CONTRIBUTOR: Nessuno\n", fp);
fclose(fp);
fp = fopen("ctest2.txt","w");
ASSERT_NE(fp,nullptr);
fputs("# CONTRIBUTOR: Pippo\n",fp);
fp = fopen("ctest2.txt", "w");
ASSERT_NE(fp, nullptr);
fputs("# CONTRIBUTOR: Pippo\n", fp);
fclose(fp);
ASSERT_TRUE(utils::file_is_readable("ctest1.txt"));
ASSERT_TRUE(utils::file_is_readable("ctest2.txt"));
ASSERT_FALSE(utils::file_is_readable("no_such_file.txt"));
ASSERT_THAT(utils::get_potential_file_path("ctest1.txt"),Eq("ctest1.txt"));
ASSERT_THAT(utils::get_potential_file_path("no_such_file.txt"),Eq(""));
ASSERT_THAT(utils::get_potential_file_path("ctest1.txt"), Eq("ctest1.txt"));
ASSERT_THAT(utils::get_potential_file_path("no_such_file.txt"), Eq(""));
const char *folder = getenv("LAMMPS_POTENTIALS");
if (folder != nullptr) {
std::string path=utils::path_join(folder,"Cu_u3.eam");
EXPECT_THAT(utils::get_potential_file_path("Cu_u3.eam"),Eq(path));
EXPECT_THAT(utils::get_potential_units(path,"EAM"),Eq("metal"));
std::string path = utils::path_join(folder, "Cu_u3.eam");
EXPECT_THAT(utils::get_potential_file_path("Cu_u3.eam"), Eq(path));
EXPECT_THAT(utils::get_potential_units(path, "EAM"), Eq("metal"));
}
ASSERT_THAT(utils::get_potential_date("ctest1.txt","Test"),Eq("2020-02-20"));
ASSERT_THAT(utils::get_potential_units("ctest1.txt","Test"),Eq("real"));
ASSERT_THAT(utils::get_potential_date("ctest2.txt","Test"),Eq(""));
ASSERT_THAT(utils::get_potential_units("ctest2.txt","Test"),Eq(""));
ASSERT_THAT(utils::get_potential_date("ctest1.txt", "Test"), Eq("2020-02-20"));
ASSERT_THAT(utils::get_potential_units("ctest1.txt", "Test"), Eq("real"));
ASSERT_THAT(utils::get_potential_date("ctest2.txt", "Test"), Eq(""));
ASSERT_THAT(utils::get_potential_units("ctest2.txt", "Test"), Eq(""));
remove("ctest1.txt");
remove("ctest2.txt");