max/iphreeqc
1
0
Fork 0
mirror of https://git.gfz-potsdam.de/naaice/iphreeqc.git synced 2025-12-15 16:18:22 +01:00
Code Issues Packages Projects Releases Wiki Activity

Updated for phreeqc changes

Browse Source 
Introduce end-of-line normalization for CMakeLists.txt
This commit is contained in:
Charlton, Scott R 2023-05-28 20:14:57 -06:00
parent a13fbe0134
commit 90a6449de8
19 changed files with 1615 additions and 1599 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
.pre-commit-config.yaml Normal file
View File

@ -0,0 +1,10 @@
repos:
- repo: https://github.com/pre-commit/pre-commit-hooks
rev: c8bad492e1b1d65d9126dba3fe3bd49a5a52b9d6 # v2.1.0
hooks:
- id: end-of-file-fixer
files: CMakeLists.txt
- id: trailing-whitespace
files: CMakeLists.txt
- id: no-commit-to-branch
args: [--branch, main, --branch, master, --branch, develop]

2
CMakeLists.txt
View File

@ -428,7 +428,7 @@ if (STANDALONE_BUILD)
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE) set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
set(BUILD_GTEST ON CACHE BOOL "" FORCE) set(BUILD_GTEST ON CACHE BOOL "" FORCE)
set(BUILD_GMOCK OFF CACHE BOOL "" FORCE) set(BUILD_GMOCK ON CACHE BOOL "" FORCE)
set(INSTALL_GTEST OFF CACHE BOOL "" FORCE) set(INSTALL_GTEST OFF CACHE BOOL "" FORCE)
set(INSTALL_GMOCK OFF CACHE BOOL "" FORCE) set(INSTALL_GMOCK OFF CACHE BOOL "" FORCE)

3
examples/com/excel/CMakeLists.txt
View File

@ -7,6 +7,3 @@ withcallback.xls
SET(Excel_Dir ${EXAMPLES_DIR}/com/excel) SET(Excel_Dir ${EXAMPLES_DIR}/com/excel)
install(FILES ${Excel_Files} DESTINATION ${Excel_Dir}) install(FILES ${Excel_Files} DESTINATION ${Excel_Dir})

3
examples/com/python/CMakeLists.txt
View File

@ -9,6 +9,3 @@ wateq4f.dat
SET(Python_Dir ${EXAMPLES_DIR}/com/python) SET(Python_Dir ${EXAMPLES_DIR}/com/python)
install(FILES ${Python_Files} DESTINATION ${Python_Dir}) install(FILES ${Python_Files} DESTINATION ${Python_Dir})

10
gtest/CMakeLists.txt
View File

@ -3,19 +3,19 @@ project(unit)
include(GoogleTest) include(GoogleTest)
add_executable(TestCVar TestCVar.cpp) add_executable(TestCVar TestCVar.cpp)
target_link_libraries(TestCVar IPhreeqc gtest gtest_main) target_link_libraries(TestCVar IPhreeqc gtest gtest_main gmock)
gtest_discover_tests(TestCVar) gtest_discover_tests(TestCVar)
add_executable(TestVar TestVar.cpp) add_executable(TestVar TestVar.cpp)
target_link_libraries(TestVar IPhreeqc gtest gtest_main) target_link_libraries(TestVar IPhreeqc gtest gtest_main gmock)
gtest_discover_tests(TestVar) gtest_discover_tests(TestVar)
add_executable(TestIPhreeqcLib TestIPhreeqcLib.cpp FileTest.cpp) add_executable(TestIPhreeqcLib TestIPhreeqcLib.cpp FileTest.cpp)
target_link_libraries(TestIPhreeqcLib IPhreeqc gtest gtest_main) target_link_libraries(TestIPhreeqcLib IPhreeqc gtest gtest_main gmock)
gtest_discover_tests(TestIPhreeqcLib) gtest_discover_tests(TestIPhreeqcLib)
add_executable(TestIPhreeqc TestIPhreeqc.cpp FileTest.cpp) add_executable(TestIPhreeqc TestIPhreeqc.cpp FileTest.cpp)
target_link_libraries(TestIPhreeqc IPhreeqc gtest gtest_main) target_link_libraries(TestIPhreeqc IPhreeqc gtest gtest_main gmock)
if (MSVC AND BUILD_SHARED_LIBS AND BUILD_CLR_LIBS) if (MSVC AND BUILD_SHARED_LIBS AND BUILD_CLR_LIBS)
# Setup references for /CLR # Setup references for /CLR
set_target_properties(TestIPhreeqc PROPERTIES VS_DOTNET_REFERENCES "${CMAKE_CURRENT_SOURCE_DIR}/../src/phreeqcpp/ZedGraph.dll") set_target_properties(TestIPhreeqc PROPERTIES VS_DOTNET_REFERENCES "${CMAKE_CURRENT_SOURCE_DIR}/../src/phreeqcpp/ZedGraph.dll")
@ -24,7 +24,7 @@ endif()
gtest_discover_tests(TestIPhreeqc) gtest_discover_tests(TestIPhreeqc)
add_executable(TestSelectedOutput TestSelectedOutput.cpp) add_executable(TestSelectedOutput TestSelectedOutput.cpp)
target_link_libraries(TestSelectedOutput IPhreeqc gtest gtest_main) target_link_libraries(TestSelectedOutput IPhreeqc gtest gtest_main gmock)
gtest_discover_tests(TestSelectedOutput) gtest_discover_tests(TestSelectedOutput)
if (MSVC AND BUILD_SHARED_LIBS) if (MSVC AND BUILD_SHARED_LIBS)

482
gtest/TestIPhreeqc.cpp
View File

@ -1,5 +1,5 @@
// -*- coding: windows-1252 -*-
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <cmath> #include <cmath>
#include <cfloat> #include <cfloat>
@ -11,6 +11,8 @@
#undef false #undef false
#include "CVar.hxx" #include "CVar.hxx"
using ::testing::HasSubstr;
VRESULT SOLUTION(IPhreeqc& obj, double C, double Ca, double Na); VRESULT SOLUTION(IPhreeqc& obj, double C, double Ca, double Na);
VRESULT EQUILIBRIUM_PHASES(IPhreeqc& obj, const char* phase, double si, double amount); VRESULT EQUILIBRIUM_PHASES(IPhreeqc& obj, const char* phase, double si, double amount);
VRESULT USER_PUNCH(IPhreeqc& obj, const char* element, int max); VRESULT USER_PUNCH(IPhreeqc& obj, const char* element, int max);
@ -1927,7 +1929,7 @@ TEST(TestIPhreeqc, TestGetDumpStringLineCount)
obj.SetDumpStringOn(true); obj.SetDumpStringOn(true);
ASSERT_EQ(true, obj.GetDumpStringOn()); ASSERT_EQ(true, obj.GetDumpStringOn());
ASSERT_EQ(0, obj.RunAccumulated()); ASSERT_EQ(0, obj.RunAccumulated());
ASSERT_EQ(33, obj.GetDumpStringLineCount()); ASSERT_EQ(34, obj.GetDumpStringLineCount());
} }
TEST(TestIPhreeqc, TestGetDumpStringLine) TEST(TestIPhreeqc, TestGetDumpStringLine)
@ -1953,43 +1955,44 @@ TEST(TestIPhreeqc, TestGetDumpStringLine)
obj.SetDumpStringOn(true); obj.SetDumpStringOn(true);
ASSERT_EQ(true, obj.GetDumpStringOn()); ASSERT_EQ(true, obj.GetDumpStringOn());
ASSERT_EQ(0, obj.RunAccumulated()); ASSERT_EQ(0, obj.RunAccumulated());
ASSERT_EQ(33, obj.GetDumpStringLineCount()); ASSERT_EQ(34, obj.GetDumpStringLineCount());
int line = 0; int line = 0;
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "SOLUTION_RAW") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("SOLUTION_RAW"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-temp") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-temp"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-pressure") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-pressure"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-potential") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-potential"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-total_h") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-total_h"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-total_o") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-total_o"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-cb") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-cb"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-density") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-density"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-totals") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-viscosity"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), " C(4) ") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-totals"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), " Ca ") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr(" C(4) "));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), " H(0) ") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr(" Ca "));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), " Na ") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr(" H(0) "));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-pH") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr(" Na "));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-pe") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-pH"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-mu") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-pe"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-ah2o") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-mu"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-mass_water") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-ah2o"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-soln_vol") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-mass_water"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-total_alkalinity") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-soln_vol"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-activities") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-total_alkalinity"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), " C(-4) ") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-activities"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), " C(4) ") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr(" C(-4) "));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), " Ca ") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr(" C(4) "));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), " E ") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr(" Ca "));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), " H(0) ") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr(" E "));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), " Na ") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr(" H(0) "));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), " O(0) ") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr(" Na "));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "-gammas") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr(" O(0) "));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "USE mix none") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("-gammas"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "USE reaction none") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("USE mix none"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "USE reaction_temperature none") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("USE reaction none"));
ASSERT_TRUE(::strstr(obj.GetDumpStringLine(line++), "USE reaction_pressure none") != NULL); EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("USE reaction_temperature none"));
EXPECT_THAT(obj.GetDumpStringLine(line++), HasSubstr("USE reaction_pressure none"));
// remaining lines should be empty // remaining lines should be empty
ASSERT_EQ(std::string(""), std::string(obj.GetDumpStringLine(line++))); ASSERT_EQ(std::string(""), std::string(obj.GetDumpStringLine(line++)));
@ -2114,7 +2117,7 @@ TEST(TestIPhreeqc, TestSetDumpFileName)
ASSERT_EQ(true, ::FileExists(DUMP_FILENAME)); ASSERT_EQ(true, ::FileExists(DUMP_FILENAME));
std::string lines[33]; std::string lines[35];
std::ifstream ifs(DUMP_FILENAME); std::ifstream ifs(DUMP_FILENAME);
size_t i = 0; size_t i = 0;
@ -2124,39 +2127,40 @@ TEST(TestIPhreeqc, TestSetDumpFileName)
} }
int line = 0; int line = 0;
ASSERT_TRUE(::strstr(lines[line++].c_str(), "SOLUTION_RAW") != NULL); EXPECT_THAT(lines[line++], HasSubstr("SOLUTION_RAW"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-temp") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-temp"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-pressure") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-pressure"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-potential") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-potential"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-total_h") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-total_h"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-total_o") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-total_o"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-cb") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-cb"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-density") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-density"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-totals") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-viscosity"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " C(4) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-totals"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Ca ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" C(4) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " H(0) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Ca "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Na ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" H(0) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-pH") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Na "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-pe") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-pH"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-mu") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-pe"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-ah2o") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-mu"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-mass_water") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-ah2o"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-soln_vol") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-mass_water"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-total_alkalinity") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-soln_vol"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-activities") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-total_alkalinity"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " C(-4) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-activities"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " C(4) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" C(-4) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Ca ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" C(4) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " E ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Ca "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " H(0) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" E "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Na ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" H(0) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " O(0) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Na "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-gammas") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" O(0) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "USE mix none") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-gammas"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "USE reaction none") != NULL); EXPECT_THAT(lines[line++], HasSubstr("USE mix none"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "USE reaction_temperature none") != NULL); EXPECT_THAT(lines[line++], HasSubstr("USE reaction none"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "USE reaction_pressure none") != NULL); EXPECT_THAT(lines[line++], HasSubstr("USE reaction_temperature none"));
EXPECT_THAT(lines[line++], HasSubstr("USE reaction_pressure none"));
if (::FileExists(DUMP_FILENAME)) if (::FileExists(DUMP_FILENAME))
{ {
@ -2218,111 +2222,111 @@ TEST(TestIPhreeqc, TestSetOutputFileName)
// but seems to not work when BUILD_SHARED_LIBS is set gtest 1.8.1 // but seems to not work when BUILD_SHARED_LIBS is set gtest 1.8.1
// see aa178fd6fac2d1c0a867385538071031e2ddedde of gtest branch // see aa178fd6fac2d1c0a867385538071031e2ddedde of gtest branch
// //
ASSERT_TRUE(::strstr(lines[line++].c_str(), "------------------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("------------------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "Reading input data for simulation 1.") != NULL); EXPECT_THAT(lines[line++], HasSubstr("Reading input data for simulation 1."));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "------------------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("------------------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " SOLUTION 1") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" SOLUTION 1"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " C 1") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" C 1"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Ca 1") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Ca 1"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Na 1") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Na 1"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " DUMP") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" DUMP"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " -solution 1") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" -solution 1"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-------------------------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-------------------------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "Beginning of initial solution calculations.") != NULL); EXPECT_THAT(lines[line++], HasSubstr("Beginning of initial solution calculations."));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-------------------------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-------------------------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "Initial solution 1. ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("Initial solution 1. "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-----------------------------Solution composition--------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-----------------------------Solution composition--------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Elements Molality Moles") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Elements Molality Moles"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " C ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" C "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Ca ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Ca "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Na ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Na "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "----------------------------Description of solution------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("----------------------------Description of solution------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " pH = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" pH = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " pe = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" pe = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Activity of water = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Activity of water = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Ionic strength (mol/kgw) = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Ionic strength (mol/kgw) = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Mass of water (kg) = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Mass of water (kg) = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Total alkalinity (eq/kg) = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Total alkalinity (eq/kg) = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Total CO2 (mol/kg) = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Total CO2 (mol/kg) = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Temperature (°C) = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Temperature (°C) = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Electrical balance (eq) = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Electrical balance (eq) = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Percent error, 100*(Cat-|An|)/(Cat+|An|) = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Percent error, 100*(Cat-|An|)/(Cat+|An|) = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Iterations = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Iterations = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Total H = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Total H = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Total O = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Total O = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "----------------------------Distribution of species----------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("----------------------------Distribution of species----------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Log Log Log mole V") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Log Log Log mole V"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Species Molality Activity Molality Activity Gamma cm³/mol") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Species Molality Activity Molality Activity Gamma cm³/mol"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " OH- ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" OH- "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " H+ ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" H+ "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " H2O ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" H2O "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "C(-4) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("C(-4) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CH4 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CH4 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "C(4) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("C(4) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " HCO3- ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" HCO3- "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CO2 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CO2 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CaHCO3+ ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CaHCO3+ "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CaCO3 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CaCO3 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CO3-2 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CO3-2 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " NaHCO3 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" NaHCO3 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " NaCO3- ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" NaCO3- "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "Ca ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("Ca "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Ca+2 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Ca+2 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CaHCO3+ ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CaHCO3+ "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CaCO3 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CaCO3 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CaOH+ ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CaOH+ "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "H(0) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("H(0) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " H2 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" H2 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "Na ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("Na "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Na+ ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Na+ "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " NaHCO3 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" NaHCO3 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " NaCO3- ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" NaCO3- "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " NaOH ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" NaOH "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "O(0) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("O(0) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " O2 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" O2 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "------------------------------Saturation indices-------------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("------------------------------Saturation indices-------------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Phase SI** log IAP log K(298 K, 1 atm)") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Phase SI** log IAP log K(298 K, 1 atm)"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Aragonite") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Aragonite"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Calcite") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Calcite"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CH4(g)") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CH4(g)"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CO2(g)") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CO2(g)"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " H2(g)") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" H2(g)"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " H2O(g)") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" H2O(g)"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " O2(g)") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" O2(g)"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "**For a gas, SI = log10(fugacity). Fugacity = pressure * phi / 1 atm.") != NULL); EXPECT_THAT(lines[line++], HasSubstr("**For a gas, SI = log10(fugacity). Fugacity = pressure * phi / 1 atm."));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " For ideal gases, phi = 1.") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" For ideal gases, phi = 1."));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "End of simulation.") != NULL); EXPECT_THAT(lines[line++], HasSubstr("End of simulation."));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "------------------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("------------------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "Reading input data for simulation 2.") != NULL); EXPECT_THAT(lines[line++], HasSubstr("Reading input data for simulation 2."));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "------------------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("------------------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
#ifndef TESTING #ifndef TESTING
ASSERT_TRUE(::strstr(lines[line++].c_str(), "----------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("----------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "End of Run after ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("End of Run after "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "----------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("----------------"));
#endif #endif
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
if (::FileExists(OUTPUT_FILENAME)) if (::FileExists(OUTPUT_FILENAME))
@ -3160,66 +3164,66 @@ TEST(TestIPhreeqc, TestGetSelectedOutputString)
std::string sline(obj.GetSelectedOutputString()); std::string sline(obj.GetSelectedOutputString());
ASSERT_TRUE(::strstr(sline.c_str(), "sim\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("sim\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "state\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("state\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "soln\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("soln\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "dist_x\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("dist_x\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "time\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("time\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "step\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("step\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "pH\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("pH\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "pe\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("pe\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "C\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("C\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "Ca\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("Ca\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "Na\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("Na\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "m_CO3-2\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("m_CO3-2\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "m_CaOH+\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("m_CaOH+\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "m_NaCO3-\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("m_NaCO3-\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "la_CO3-2\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("la_CO3-2\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "la_CaOH+\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("la_CaOH+\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "la_NaCO3-\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("la_NaCO3-\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "Calcite\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("Calcite\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "d_Calcite\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("d_Calcite\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "si_CO2(g)\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("si_CO2(g)\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "si_Siderite\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("si_Siderite\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "pressure\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("pressure\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "total mol\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("total mol\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "volume\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("volume\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "g_CO2(g)\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("g_CO2(g)\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "g_N2(g)\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("g_N2(g)\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "k_Albite\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("k_Albite\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "dk_Albite\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("dk_Albite\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "k_Pyrite\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("k_Pyrite\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "dk_Pyrite\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("dk_Pyrite\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "s_CaSO4\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("s_CaSO4\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "s_SrSO4\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("s_SrSO4\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "1.name\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("1.name\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "1.type\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("1.type\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "1.moles\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("1.moles\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "2.name\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("2.name\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "2.type\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("2.type\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "2.moles\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("2.moles\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "3.name\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("3.name\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "3.type\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("3.type\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "3.moles\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("3.moles\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "4.name\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("4.name\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "4.type\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("4.type\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "4.moles\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("4.moles\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "5.name\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("5.name\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "5.type\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("5.type\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "5.moles\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("5.moles\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "6.name\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("6.name\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "6.type\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("6.type\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "6.moles\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("6.moles\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "\n") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("\n"));
ASSERT_TRUE(::strstr(sline.c_str(), "i_soln\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("i_soln\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "react\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("react\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "Ca+2\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("Ca+2\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "aq\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("aq\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "CaHCO3+\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("CaHCO3+\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "CaCO3\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("CaCO3\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "CaOH+\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("CaOH+\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "Calcite\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("Calcite\t"));
ASSERT_TRUE(::strstr(sline.c_str(), "equi\t") != NULL); EXPECT_THAT(sline.c_str(), HasSubstr("equi\t"));
} }
TEST(TestIPhreeqc, TestGetSelectedOutputStringLineCount) TEST(TestIPhreeqc, TestGetSelectedOutputStringLineCount)
@ -4100,12 +4104,12 @@ TEST(TestIPhreeqc, TestMultiPunchCSelectedOutput)
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(6, 0, &var)); ASSERT_NEAR(-7.60411, var.dVal, ::pow(10., -2)); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(6, 0, &var)); ASSERT_NEAR(-7.60411, var.dVal, ::pow(10., -2));
// si_Calcite // si_Calcite
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(1, 1, &var)); ASSERT_NEAR(0.692077, var.dVal, ::pow(10., -2)); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(1, 1, &var)); ASSERT_NEAR(0.702316, var.dVal, ::pow(10., -2));
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(2, 1, &var)); ASSERT_NEAR(0.678847, var.dVal, ::pow(10., -2)); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(2, 1, &var)); ASSERT_NEAR(0.695856, var.dVal, ::pow(10., -2));
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(3, 1, &var)); ASSERT_NEAR(0.678847, var.dVal, ::pow(10., -2)); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(3, 1, &var)); ASSERT_NEAR(0.689518, var.dVal, ::pow(10., -2));
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(4, 1, &var)); ASSERT_NEAR(-999.999, var.dVal, ::pow(10., -2)); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(4, 1, &var)); ASSERT_NEAR(-999.999, var.dVal, ::pow(10., -2));
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(5, 1, &var)); ASSERT_NEAR(-999.999, var.dVal, ::pow(10., -2)); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(5, 1, &var)); ASSERT_NEAR(-999.999, var.dVal, ::pow(10., -2));
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(6, 1, &var)); ASSERT_NEAR(0.672429, var.dVal, ::pow(10., -2)); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(6, 1, &var)); ASSERT_NEAR(0.683300, var.dVal, ::pow(10., -2));
// DUMMY_1 // DUMMY_1
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(1, 2, &var)); ASSERT_EQ(TT_EMPTY, var.type); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(1, 2, &var)); ASSERT_EQ(TT_EMPTY, var.type);
@ -4129,7 +4133,7 @@ TEST(TestIPhreeqc, TestMultiPunchCSelectedOutput)
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(3, 4, &var)); ASSERT_EQ(TT_EMPTY, var.type); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(3, 4, &var)); ASSERT_EQ(TT_EMPTY, var.type);
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(4, 4, &var)); ASSERT_EQ(TT_EMPTY, var.type); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(4, 4, &var)); ASSERT_EQ(TT_EMPTY, var.type);
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(5, 4, &var)); ASSERT_EQ(TT_EMPTY, var.type); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(5, 4, &var)); ASSERT_EQ(TT_EMPTY, var.type);
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(6, 4, &var)); ASSERT_NEAR(3.69E-13, var.dVal, ::pow(10., log10(3.69E-13) - 2)); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(6, 4, &var)); ASSERT_NEAR(4.12e-13, var.dVal, ::pow(10., log10(4.12e-13) - 2));
// Sum_Delta/U // Sum_Delta/U
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(1, 5, &var)); ASSERT_EQ(TT_EMPTY, var.type); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(1, 5, &var)); ASSERT_EQ(TT_EMPTY, var.type);
@ -4247,7 +4251,7 @@ TEST(TestIPhreeqc, TestMultiPunchCSelectedOutput)
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(0, ncol++, &var)); ASSERT_EQ(std::string("Halite_max"), std::string(var.sVal)); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(0, ncol++, &var)); ASSERT_EQ(std::string("Halite_max"), std::string(var.sVal));
// Sum_resid // Sum_resid
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(1, 0, &var)); ASSERT_NEAR(3.69E-13, var.dVal, ::pow(10., log10(3.69E-13) - 2)); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(1, 0, &var)); ASSERT_NEAR(4.12e-13, var.dVal, ::pow(10., log10(4.12e-13) - 2));
// Sum_Delta/U // Sum_Delta/U
ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(1, 1, &var)); ASSERT_NEAR(0, var.dVal, ::pow(10., -3)); ASSERT_EQ(VR_OK, obj.GetSelectedOutputValue(1, 1, &var)); ASSERT_NEAR(0, var.dVal, ::pow(10., -3));

424
gtest/TestIPhreeqcLib.cpp
View File

@ -1,10 +1,12 @@
// -*- coding: windows-1252 -*-
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "IPhreeqc.h" #include "IPhreeqc.h"
#include "Phreeqc.h" /* snprintf */ #include "Phreeqc.h" /* snprintf */
#include "CVar.hxx" #include "CVar.hxx"
using ::testing::HasSubstr;
#if defined(_WIN32) #if defined(_WIN32)
#include <windows.h> #include <windows.h>
#endif #endif
@ -1756,35 +1758,39 @@ TEST(TestIPhreeqcLib, TestDumpString)
const char* dump_str = ::GetDumpString(n); const char* dump_str = ::GetDumpString(n);
ASSERT_TRUE(::strstr(dump_str, "SOLUTION_RAW") != NULL); EXPECT_THAT(dump_str, HasSubstr("SOLUTION_RAW"));
ASSERT_TRUE(::strstr(dump_str, "-temp") != NULL); EXPECT_THAT(dump_str, HasSubstr("-temp"));
ASSERT_TRUE(::strstr(dump_str, "-total_h") != NULL); EXPECT_THAT(dump_str, HasSubstr("-pressure"));
ASSERT_TRUE(::strstr(dump_str, "-total_o") != NULL); EXPECT_THAT(dump_str, HasSubstr("-potential"));
ASSERT_TRUE(::strstr(dump_str, "-cb") != NULL); EXPECT_THAT(dump_str, HasSubstr("-total_h"));
ASSERT_TRUE(::strstr(dump_str, "-totals") != NULL); EXPECT_THAT(dump_str, HasSubstr("-total_o"));
ASSERT_TRUE(::strstr(dump_str, " C(4) ") != NULL); EXPECT_THAT(dump_str, HasSubstr("-cb"));
ASSERT_TRUE(::strstr(dump_str, " Ca ") != NULL); EXPECT_THAT(dump_str, HasSubstr("-density"));
ASSERT_TRUE(::strstr(dump_str, " H(0) ") != NULL); EXPECT_THAT(dump_str, HasSubstr("-viscosity"));
ASSERT_TRUE(::strstr(dump_str, " Na ") != NULL); EXPECT_THAT(dump_str, HasSubstr("-totals"));
ASSERT_TRUE(::strstr(dump_str, "-pH") != NULL); EXPECT_THAT(dump_str, HasSubstr(" C(4) "));
ASSERT_TRUE(::strstr(dump_str, "-pe") != NULL); EXPECT_THAT(dump_str, HasSubstr(" Ca "));
ASSERT_TRUE(::strstr(dump_str, "-mu") != NULL); EXPECT_THAT(dump_str, HasSubstr(" H(0) "));
ASSERT_TRUE(::strstr(dump_str, "-ah2o") != NULL); EXPECT_THAT(dump_str, HasSubstr(" Na "));
ASSERT_TRUE(::strstr(dump_str, "-mass_water") != NULL); EXPECT_THAT(dump_str, HasSubstr("-pH"));
ASSERT_TRUE(::strstr(dump_str, "-total_alkalinity") != NULL); EXPECT_THAT(dump_str, HasSubstr("-pe"));
ASSERT_TRUE(::strstr(dump_str, "-activities") != NULL); EXPECT_THAT(dump_str, HasSubstr("-mu"));
ASSERT_TRUE(::strstr(dump_str, " C(-4) ") != NULL); EXPECT_THAT(dump_str, HasSubstr("-ah2o"));
ASSERT_TRUE(::strstr(dump_str, " C(4) ") != NULL); EXPECT_THAT(dump_str, HasSubstr("-mass_water"));
ASSERT_TRUE(::strstr(dump_str, " Ca ") != NULL); EXPECT_THAT(dump_str, HasSubstr("-total_alkalinity"));
ASSERT_TRUE(::strstr(dump_str, " E ") != NULL); EXPECT_THAT(dump_str, HasSubstr("-activities"));
ASSERT_TRUE(::strstr(dump_str, " H(0) ") != NULL); EXPECT_THAT(dump_str, HasSubstr(" C(-4) "));
ASSERT_TRUE(::strstr(dump_str, " Na ") != NULL); EXPECT_THAT(dump_str, HasSubstr(" C(4) "));
ASSERT_TRUE(::strstr(dump_str, " O(0) ") != NULL); EXPECT_THAT(dump_str, HasSubstr(" Ca "));
ASSERT_TRUE(::strstr(dump_str, "-gammas") != NULL); EXPECT_THAT(dump_str, HasSubstr(" E "));
ASSERT_TRUE(::strstr(dump_str, "USE mix none") != NULL); EXPECT_THAT(dump_str, HasSubstr(" H(0) "));
ASSERT_TRUE(::strstr(dump_str, "USE reaction none") != NULL); EXPECT_THAT(dump_str, HasSubstr(" Na "));
ASSERT_TRUE(::strstr(dump_str, "USE reaction_temperature none") != NULL); EXPECT_THAT(dump_str, HasSubstr(" O(0) "));
ASSERT_TRUE(::strstr(dump_str, "USE reaction_pressure none") != NULL); EXPECT_THAT(dump_str, HasSubstr("-gammas"));
EXPECT_THAT(dump_str, HasSubstr("USE mix none"));
EXPECT_THAT(dump_str, HasSubstr("USE reaction none"));
EXPECT_THAT(dump_str, HasSubstr("USE reaction_temperature none"));
EXPECT_THAT(dump_str, HasSubstr("USE reaction_pressure none"));
if (n >= 0) if (n >= 0)
{ {
@ -1813,7 +1819,7 @@ TEST(TestIPhreeqcLib, TestGetDumpStringLineCount)
ASSERT_EQ(IPQ_OK, ::SetDumpFileOn(n, 0)); ASSERT_EQ(IPQ_OK, ::SetDumpFileOn(n, 0));
ASSERT_EQ(IPQ_OK, ::SetDumpStringOn(n, 1)); ASSERT_EQ(IPQ_OK, ::SetDumpStringOn(n, 1));
ASSERT_EQ(0, ::RunAccumulated(n)); ASSERT_EQ(0, ::RunAccumulated(n));
ASSERT_EQ(33, ::GetDumpStringLineCount(n)); ASSERT_EQ(34, ::GetDumpStringLineCount(n));
if (n >= 0) if (n >= 0)
{ {
@ -1842,43 +1848,44 @@ TEST(TestIPhreeqcLib, TestGetDumpStringLine)
ASSERT_EQ(IPQ_OK, ::SetDumpFileOn(n, 0)); ASSERT_EQ(IPQ_OK, ::SetDumpFileOn(n, 0));
ASSERT_EQ(IPQ_OK, ::SetDumpStringOn(n, 1)); ASSERT_EQ(IPQ_OK, ::SetDumpStringOn(n, 1));
ASSERT_EQ(0, ::RunAccumulated(n)); ASSERT_EQ(0, ::RunAccumulated(n));
ASSERT_EQ(33, ::GetDumpStringLineCount(n)); ASSERT_EQ(34, ::GetDumpStringLineCount(n));
int line = 0; int line = 0;
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "SOLUTION_RAW") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("SOLUTION_RAW"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-temp") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-temp"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-pressure") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-pressure"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-potential") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-potential"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-total_h") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-total_h"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-total_o") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-total_o"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-cb") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-cb"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-density") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-density"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-totals") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-viscosity"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), " C(4) ") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-totals"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), " Ca ") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr(" C(4) "));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), " H(0) ") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr(" Ca "));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), " Na ") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr(" H(0) "));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-pH") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr(" Na "));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-pe") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-pH"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-mu") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-pe"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-ah2o") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-mu"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-mass_water") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-ah2o"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-soln_vol") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-mass_water"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-total_alkalinity") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-soln_vol"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-activities") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-total_alkalinity"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), " C(-4) ") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-activities"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), " C(4) ") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr(" C(-4) "));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), " Ca ") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr(" C(4) "));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), " E ") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr(" Ca "));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), " H(0) ") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr(" E "));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), " Na ") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr(" H(0) "));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), " O(0) ") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr(" Na "));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "-gammas") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr(" O(0) "));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "USE mix none") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("-gammas"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "USE reaction none") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("USE mix none"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "USE reaction_temperature none") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("USE reaction none"));
ASSERT_TRUE(::strstr(::GetDumpStringLine(n, line++), "USE reaction_pressure none") != NULL); EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("USE reaction_temperature none"));
EXPECT_THAT(::GetDumpStringLine(n, line++), HasSubstr("USE reaction_pressure none"));
// remaining lines should be empty // remaining lines should be empty
ASSERT_EQ(std::string(""), std::string(::GetDumpStringLine(n, line++))); ASSERT_EQ(std::string(""), std::string(::GetDumpStringLine(n, line++)));
@ -2328,7 +2335,7 @@ TEST(TestIPhreeqcLib, TestSetDumpFileName)
ASSERT_EQ(true, ::FileExists(DUMP_FILENAME)); ASSERT_EQ(true, ::FileExists(DUMP_FILENAME));
std::string lines[33]; std::string lines[35];
std::ifstream ifs(DUMP_FILENAME); std::ifstream ifs(DUMP_FILENAME);
size_t i = 0; size_t i = 0;
@ -2338,39 +2345,40 @@ TEST(TestIPhreeqcLib, TestSetDumpFileName)
} }
int line = 0; int line = 0;
ASSERT_TRUE(::strstr(lines[line++].c_str(), "SOLUTION_RAW") != NULL); EXPECT_THAT(lines[line++], HasSubstr("SOLUTION_RAW"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-temp") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-temp"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-pressure") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-pressure"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-potential") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-potential"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-total_h") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-total_h"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-total_o") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-total_o"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-cb") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-cb"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-density") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-density"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-totals") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-viscosity"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " C(4) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-totals"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Ca ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" C(4) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " H(0) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Ca "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Na ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" H(0) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-pH") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Na "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-pe") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-pH"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-mu") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-pe"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-ah2o") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-mu"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-mass_water") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-ah2o"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-soln_vol") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-mass_water"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-total_alkalinity") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-soln_vol"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-activities") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-total_alkalinity"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " C(-4) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-activities"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " C(4) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" C(-4) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Ca ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" C(4) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " E ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Ca "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " H(0) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" E "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Na ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" H(0) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " O(0) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Na "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-gammas") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" O(0) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "USE mix none") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-gammas"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "USE reaction none") != NULL); EXPECT_THAT(lines[line++], HasSubstr("USE mix none"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "USE reaction_temperature none") != NULL); EXPECT_THAT(lines[line++], HasSubstr("USE reaction none"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "USE reaction_pressure none") != NULL); EXPECT_THAT(lines[line++], HasSubstr("USE reaction_temperature none"));
EXPECT_THAT(lines[line++], HasSubstr("USE reaction_pressure none"));
if (::FileExists(DUMP_FILENAME)) if (::FileExists(DUMP_FILENAME))
{ {
@ -2436,111 +2444,111 @@ TEST(TestIPhreeqcLib, TestSetOutputFileName)
int line = 0; int line = 0;
ASSERT_TRUE(::strstr(lines[line++].c_str(), "------------------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("------------------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "Reading input data for simulation 1.") != NULL); EXPECT_THAT(lines[line++], HasSubstr("Reading input data for simulation 1."));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "------------------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("------------------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " SOLUTION 1") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" SOLUTION 1"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " C 1") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" C 1"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Ca 1") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Ca 1"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Na 1") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Na 1"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " DUMP") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" DUMP"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " -solution 1") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" -solution 1"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-------------------------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-------------------------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "Beginning of initial solution calculations.") != NULL); EXPECT_THAT(lines[line++], HasSubstr("Beginning of initial solution calculations."));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-------------------------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-------------------------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "Initial solution 1. ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("Initial solution 1. "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "-----------------------------Solution composition--------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("-----------------------------Solution composition--------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Elements Molality Moles") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Elements Molality Moles"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " C ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" C "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Ca ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Ca "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Na ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Na "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "----------------------------Description of solution------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("----------------------------Description of solution------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " pH = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" pH = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " pe = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" pe = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Activity of water = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Activity of water = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Ionic strength (mol/kgw) = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Ionic strength (mol/kgw) = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Mass of water (kg) = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Mass of water (kg) = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Total alkalinity (eq/kg) = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Total alkalinity (eq/kg) = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Total CO2 (mol/kg) = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Total CO2 (mol/kg) = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Temperature (°C) = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Temperature (°C) = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Electrical balance (eq) = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Electrical balance (eq) = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Percent error, 100*(Cat-|An|)/(Cat+|An|) = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Percent error, 100*(Cat-|An|)/(Cat+|An|) = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Iterations = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Iterations = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Total H = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Total H = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Total O = ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Total O = "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "----------------------------Distribution of species----------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("----------------------------Distribution of species----------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Log Log Log mole V") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Log Log Log mole V"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Species Molality Activity Molality Activity Gamma cm³/mol") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Species Molality Activity Molality Activity Gamma cm³/mol"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " OH- ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" OH- "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " H+ ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" H+ "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " H2O ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" H2O "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "C(-4) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("C(-4) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CH4 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CH4 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "C(4) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("C(4) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " HCO3- ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" HCO3- "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CO2 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CO2 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CaHCO3+ ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CaHCO3+ "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CaCO3 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CaCO3 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CO3-2 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CO3-2 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " NaHCO3 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" NaHCO3 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " NaCO3- ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" NaCO3- "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "Ca ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("Ca "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Ca+2 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Ca+2 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CaHCO3+ ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CaHCO3+ "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CaCO3 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CaCO3 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CaOH+ ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CaOH+ "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "H(0) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("H(0) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " H2 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" H2 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "Na ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("Na "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Na+ ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Na+ "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " NaHCO3 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" NaHCO3 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " NaCO3- ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" NaCO3- "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " NaOH ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" NaOH "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "O(0) ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("O(0) "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " O2 ") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" O2 "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "------------------------------Saturation indices-------------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("------------------------------Saturation indices-------------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Phase SI** log IAP log K(298 K, 1 atm)") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Phase SI** log IAP log K(298 K, 1 atm)"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Aragonite") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Aragonite"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " Calcite") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" Calcite"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CH4(g)") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CH4(g)"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " CO2(g)") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" CO2(g)"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " H2(g)") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" H2(g)"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " H2O(g)") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" H2O(g)"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " O2(g)") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" O2(g)"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "**For a gas, SI = log10(fugacity). Fugacity = pressure * phi / 1 atm.") != NULL); EXPECT_THAT(lines[line++], HasSubstr("**For a gas, SI = log10(fugacity). Fugacity = pressure * phi / 1 atm."));
ASSERT_TRUE(::strstr(lines[line++].c_str(), " For ideal gases, phi = 1.") != NULL); EXPECT_THAT(lines[line++], HasSubstr(" For ideal gases, phi = 1."));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "End of simulation.") != NULL); EXPECT_THAT(lines[line++], HasSubstr("End of simulation."));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "------------------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("------------------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "Reading input data for simulation 2.") != NULL); EXPECT_THAT(lines[line++], HasSubstr("Reading input data for simulation 2."));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "------------------------------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("------------------------------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
#ifndef TESTING #ifndef TESTING
ASSERT_TRUE(::strstr(lines[line++].c_str(), "----------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("----------------"));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "End of Run after ") != NULL); EXPECT_THAT(lines[line++], HasSubstr("End of Run after "));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "----------------") != NULL); EXPECT_THAT(lines[line++], HasSubstr("----------------"));
#endif #endif
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
ASSERT_TRUE(::strstr(lines[line++].c_str(), "") != NULL); EXPECT_THAT(lines[line++], HasSubstr(""));
///#endif ///#endif
if (n >= 0) if (n >= 0)
@ -4175,12 +4183,12 @@ TEST(TestIPhreeqcLib, TestMultiPunchCSelectedOutput)
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 6, 0, &var)); ASSERT_NEAR(-7.60411, var.dVal, ::pow(10., -2)); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 6, 0, &var)); ASSERT_NEAR(-7.60411, var.dVal, ::pow(10., -2));
// si_Calcite // si_Calcite
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 1, 1, &var)); ASSERT_NEAR(0.692077, var.dVal, ::pow(10., -2)); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 1, 1, &var)); ASSERT_NEAR(0.702316, var.dVal, ::pow(10., -2));
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 2, 1, &var)); ASSERT_NEAR(0.678847, var.dVal, ::pow(10., -2)); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 2, 1, &var)); ASSERT_NEAR(0.695856, var.dVal, ::pow(10., -2));
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 3, 1, &var)); ASSERT_NEAR(0.678847, var.dVal, ::pow(10., -2)); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 3, 1, &var)); ASSERT_NEAR(0.689518, var.dVal, ::pow(10., -2));
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 4, 1, &var)); ASSERT_NEAR(-999.999, var.dVal, ::pow(10., -2)); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 4, 1, &var)); ASSERT_NEAR(-999.999, var.dVal, ::pow(10., -2));
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 5, 1, &var)); ASSERT_NEAR(-999.999, var.dVal, ::pow(10., -2)); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 5, 1, &var)); ASSERT_NEAR(-999.999, var.dVal, ::pow(10., -2));
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 6, 1, &var)); ASSERT_NEAR(0.672429, var.dVal, ::pow(10., -2)); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 6, 1, &var)); ASSERT_NEAR(0.683300, var.dVal, ::pow(10., -2));
// DUMMY_1 // DUMMY_1
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 1, 2, &var)); ASSERT_EQ(TT_EMPTY, var.type); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 1, 2, &var)); ASSERT_EQ(TT_EMPTY, var.type);
@ -4204,7 +4212,7 @@ TEST(TestIPhreeqcLib, TestMultiPunchCSelectedOutput)
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 3, 4, &var)); ASSERT_EQ(TT_EMPTY, var.type); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 3, 4, &var)); ASSERT_EQ(TT_EMPTY, var.type);
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 4, 4, &var)); ASSERT_EQ(TT_EMPTY, var.type); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 4, 4, &var)); ASSERT_EQ(TT_EMPTY, var.type);
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 5, 4, &var)); ASSERT_EQ(TT_EMPTY, var.type); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 5, 4, &var)); ASSERT_EQ(TT_EMPTY, var.type);
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 6, 4, &var)); ASSERT_NEAR(3.69E-13, var.dVal, ::pow(10., log10(3.69E-13) - 2)); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 6, 4, &var)); ASSERT_NEAR(4.12e-13, var.dVal, ::pow(10., log10(4.12e-13) - 2));
// Sum_Delta/U // Sum_Delta/U
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 1, 5, &var)); ASSERT_EQ(TT_EMPTY, var.type); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 1, 5, &var)); ASSERT_EQ(TT_EMPTY, var.type);
@ -4322,7 +4330,7 @@ TEST(TestIPhreeqcLib, TestMultiPunchCSelectedOutput)
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 0, ncol++, &var)); ASSERT_EQ(std::string("Halite_max"), std::string(var.sVal)); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 0, ncol++, &var)); ASSERT_EQ(std::string("Halite_max"), std::string(var.sVal));
// Sum_resid // Sum_resid
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 1, 0, &var)); ASSERT_NEAR(3.69E-13, var.dVal, ::pow(10., log10(3.69E-13) - 2)); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 1, 0, &var)); ASSERT_NEAR(4.12E-13, var.dVal, ::pow(10., log10(4.12E-13) - 2));
// Sum_Delta/U // Sum_Delta/U
ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 1, 1, &var)); ASSERT_NEAR(0, var.dVal, ::pow(10., -3)); ASSERT_EQ(IPQ_OK, ::GetSelectedOutputValue(id, 1, 1, &var)); ASSERT_NEAR(0, var.dVal, ::pow(10., -3));