From 0b19b7c1973adab55e0014c063bef82e132835e1 Mon Sep 17 00:00:00 2001
From: Hannes Signer <hm.signer@gmail.com>
Date: Sun, 6 Aug 2023 22:14:03 +0200
Subject: [PATCH] add test cases for Boundary class and additional input
 validation

---
 src/Boundary.cpp      | 26 +++++++++++++++++
 test/testBoundary.cpp | 68 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 94 insertions(+)
 create mode 100644 test/testBoundary.cpp

diff --git a/src/Boundary.cpp b/src/Boundary.cpp
index 18f3daf..da3a3e4 100644
--- a/src/Boundary.cpp
+++ b/src/Boundary.cpp
@@ -26,6 +26,11 @@ void BoundaryElement::setValue(double value) {
     if(value < 0){
         throw_invalid_argument("No negative concentration allowed.");
     }
+    if(type == BC_TYPE_CLOSED){
+      throw_invalid_argument(
+          "No constant boundary concentrations can be set for closed "
+          "boundaries. Please change type first.");
+    }
     this->value = value;
 }
 
@@ -56,10 +61,24 @@ Boundary::Boundary(Grid grid) : grid(grid) {
 }
 
 void Boundary::setBoundarySideClosed(BC_SIDE side) {
+    if(grid.getDim() == 1){
+        if((side == BC_SIDE_BOTTOM) || (side == BC_SIDE_TOP)){
+          throw_invalid_argument(
+              "For the one-dimensional trap, only the BC_SIDE_LEFT and "
+              "BC_SIDE_RIGHT borders exist.");
+        }
+    }
     this->boundaries[side] = vector<BoundaryElement>(grid.getRow(), BoundaryElement());
 }
 
 void Boundary::setBoundarySideConstant(BC_SIDE side, double value) {
+    if(grid.getDim() == 1){
+        if((side == BC_SIDE_BOTTOM) || (side == BC_SIDE_TOP)){
+          throw_invalid_argument(
+              "For the one-dimensional trap, only the BC_SIDE_LEFT and "
+              "BC_SIDE_RIGHT borders exist.");
+        }
+    }
     this->boundaries[side] = vector<BoundaryElement>(grid.getRow(), BoundaryElement(value));
 }
 
@@ -81,6 +100,13 @@ void Boundary::setBoundaryElementConstant(BC_SIDE side, int index, double value)
 }
 
 vector<BoundaryElement> Boundary::getBoundarySide(BC_SIDE side) {
+    if(grid.getDim() == 1){
+        if((side == BC_SIDE_BOTTOM) || (side == BC_SIDE_TOP)){
+          throw_invalid_argument(
+              "For the one-dimensional trap, only the BC_SIDE_LEFT and "
+              "BC_SIDE_RIGHT borders exist.");
+        }
+    }
     return this->boundaries[side];
 }
 
diff --git a/test/testBoundary.cpp b/test/testBoundary.cpp
new file mode 100644
index 0000000..47ca1fa
--- /dev/null
+++ b/test/testBoundary.cpp
@@ -0,0 +1,68 @@
+#include <stdio.h>
+#include <doctest/doctest.h>
+#include <tug/Boundary.hpp>
+#include <string>
+#include <typeinfo>
+#include <iostream>
+
+TEST_CASE("BoundaryElement"){
+
+    SUBCASE("Closed case"){
+        BoundaryElement boundaryElementClosed = BoundaryElement();
+        CHECK_NOTHROW(BoundaryElement());
+        CHECK_EQ(boundaryElementClosed.getType(), BC_TYPE_CLOSED);
+        CHECK_EQ(isnan(boundaryElementClosed.getValue()), isnan(NAN));
+        CHECK_THROWS(boundaryElementClosed.setValue(0.2));
+    }
+
+    SUBCASE("Constant case"){
+        BoundaryElement boundaryElementConstant = BoundaryElement(0.1);
+        CHECK_NOTHROW(BoundaryElement(0.1));
+        CHECK_EQ(boundaryElementConstant.getType(), BC_TYPE_CONSTANT);
+        CHECK_EQ(boundaryElementConstant.getValue(), 0.1);
+        CHECK_NOTHROW(boundaryElementConstant.setValue(0.2));
+        CHECK_EQ(boundaryElementConstant.getValue(), 0.2);
+    }
+}
+
+TEST_CASE("Boundary Class"){
+    Grid grid1D = Grid(10);
+    Grid grid2D = Grid(10, 12);
+    Boundary boundary1D = Boundary(grid1D);
+    Boundary boundary2D = Boundary(grid2D);
+    vector<BoundaryElement> boundary1DVector(1, BoundaryElement(1.0));
+
+    SUBCASE("Boundaries 1D case"){
+        CHECK_NOTHROW(Boundary boundary(grid1D));
+        CHECK_EQ(boundary1D.getBoundarySide(BC_SIDE_LEFT).size(), 1);
+        CHECK_EQ(boundary1D.getBoundarySide(BC_SIDE_RIGHT).size(), 1);
+        CHECK_EQ(boundary1D.getBoundaryElementType(BC_SIDE_LEFT, 0), BC_TYPE_CLOSED);
+        CHECK_THROWS(boundary1D.getBoundarySide(BC_SIDE_TOP));
+        CHECK_THROWS(boundary1D.getBoundarySide(BC_SIDE_BOTTOM));
+        CHECK_NOTHROW(boundary1D.setBoundarySideClosed(BC_SIDE_LEFT));
+        CHECK_THROWS(boundary1D.setBoundarySideClosed(BC_SIDE_TOP));
+        CHECK_NOTHROW(boundary1D.setBoundarySideConstant(BC_SIDE_LEFT, 1.0));
+        CHECK_EQ(boundary1D.getBoundaryElementValue(BC_SIDE_LEFT, 0), 1.0);
+        CHECK_THROWS(boundary1D.getBoundaryElementValue(BC_SIDE_LEFT, 2));
+        CHECK_EQ(boundary1D.getBoundaryElementType(BC_SIDE_LEFT, 0), BC_TYPE_CONSTANT);
+        CHECK_EQ(boundary1D.getBoundaryElement(BC_SIDE_LEFT, 0).getType(), boundary1DVector[0].getType());
+    }
+
+    SUBCASE("Boundaries 2D case"){
+        CHECK_NOTHROW(Boundary boundary(grid1D));
+        CHECK_EQ(boundary2D.getBoundarySide(BC_SIDE_LEFT).size(), 10);
+        CHECK_EQ(boundary2D.getBoundarySide(BC_SIDE_RIGHT).size(), 10);
+        CHECK_EQ(boundary2D.getBoundarySide(BC_SIDE_TOP).size(), 12);
+        CHECK_EQ(boundary2D.getBoundarySide(BC_SIDE_BOTTOM).size(), 12);
+        CHECK_EQ(boundary2D.getBoundaryElementType(BC_SIDE_LEFT, 0), BC_TYPE_CLOSED);
+        CHECK_NOTHROW(boundary2D.getBoundarySide(BC_SIDE_TOP));
+        CHECK_NOTHROW(boundary2D.getBoundarySide(BC_SIDE_BOTTOM));
+        CHECK_NOTHROW(boundary2D.setBoundarySideClosed(BC_SIDE_LEFT));
+        CHECK_NOTHROW(boundary2D.setBoundarySideClosed(BC_SIDE_TOP));
+        CHECK_NOTHROW(boundary2D.setBoundarySideConstant(BC_SIDE_LEFT, 1.0));
+        CHECK_EQ(boundary2D.getBoundaryElementValue(BC_SIDE_LEFT, 0), 1.0);
+        CHECK_THROWS(boundary2D.getBoundaryElementValue(BC_SIDE_LEFT, 12));
+        CHECK_EQ(boundary2D.getBoundaryElementType(BC_SIDE_LEFT, 0), BC_TYPE_CONSTANT);
+        CHECK_EQ(boundary2D.getBoundaryElement(BC_SIDE_LEFT, 0).getType(), boundary1DVector[0].getType());
+    }
+}
\ No newline at end of file