[hist] Test against long long truncation

Add and use function Internal::SetBinContent not exposed in the public
interface.

Author: hahnjo

hist/histv7/inc/ROOT/RHistEngine.hxx

@@ -25,6 +25,15 @@ class TBuffer;
 namespace ROOT {
 namespace Experimental {
 
+// forward declarations for friend declaration
+template <typename BinContentType>
+class RHistEngine;
+namespace Internal {
+template <typename T, std::size_t N>
+static void
+SetBinContent(RHistEngine<T> &hist, const std::array<RBinIndex, N> &indices, const T &value);
+} // namespace Internal
+
 /**
 A histogram data structure to bin data along multiple dimensions.
 
@@ -57,6 +66,9 @@ Feedback is welcome!
 */
 template <typename BinContentType>
 class RHistEngine final {
+   template <typename T, std::size_t N>
+   friend void Internal::SetBinContent(RHistEngine<T> &, const std::array<RBinIndex, N> &, const T &);
+
    /// The axis configuration for this histogram. Relevant methods are forwarded from the public interface.
    Internal::RAxes fAxes;
    /// The bin contents for this histogram
@@ -330,6 +342,21 @@ public:
    void Streamer(TBuffer &) { throw std::runtime_error("unable to store RHistEngine"); }
 };
 
+namespace Internal {
+/// %Internal function to set the content of a single bin.
+template <typename T, std::size_t N>
+static void
+SetBinContent(RHistEngine<T> &hist, const std::array<RBinIndex, N> &indices, const T &value)
+{
+   RLinearizedIndex index = hist.fAxes.ComputeGlobalIndex(indices);
+   if (!index.fValid) {
+      throw std::invalid_argument("bin not found in SetBinContent");
+   }
+   assert(index.fIndex < hist.fBinContents.size());
+   hist.fBinContents[index.fIndex] = value;
+}
+} // namespace Internal
+
 } // namespace Experimental
 } // namespace ROOT
 

hist/histv7/test/hist_engine.cxx

@@ -1,5 +1,6 @@
 #include "hist_test.hxx"
 
+#include <array>
 #include <stdexcept>
 #include <type_traits>
 #include <variant>
@@ -71,6 +72,23 @@ TEST(RHistEngine, GetBinContentNotFound)
    EXPECT_THROW(engine.GetBinContent(Bins), std::invalid_argument);
 }
 
+TEST(RHistEngine, SetBinContent)
+{
+   using ROOT::Experimental::Internal::SetBinContent;
+
+   static constexpr std::size_t Bins = 20;
+   const RRegularAxis axis(Bins, {0, Bins});
+   RHistEngine<int> engine({axis});
+
+   std::array<RBinIndex, 1> indices = {7};
+   SetBinContent(engine, indices, 42);
+   EXPECT_EQ(engine.GetBinContent(indices), 42);
+
+   // "bin not found"
+   indices = {Bins};
+   EXPECT_THROW(SetBinContent(engine, indices, 43), std::invalid_argument);
+}
+
 TEST(RHistEngine, Add)
 {
    static constexpr std::size_t Bins = 20;

hist/histv7util/test/hist_convert_TH1.cxx

@@ -3,6 +3,7 @@
 #include <TAxis.h>
 #include <TH1.h>
 
+#include <array>
 #include <cstddef>
 #include <memory>
 #include <stdexcept>
@@ -142,11 +143,21 @@ TEST(ConvertToTH1L, RHistEngine)
    auto th1l = ConvertToTH1L(engineL);
    ASSERT_TRUE(th1l);
 
-   const RHistEngine<long long> engineLL(Bins, {0, Bins});
+   RHistEngine<long long> engineLL(Bins, {0, Bins});
+
+   // Set one 64-bit long long value larger than what double can exactly represent.
+   static constexpr long long Large = (1LL << 60) - 1;
+   const std::array<RBinIndex, 1> indices = {1};
+   ROOT::Experimental::Internal::SetBinContent(engineLL, indices, Large);
+
    th1l = ConvertToTH1L(engineLL);
    ASSERT_TRUE(th1l);
 
-   // TODO: Test that 64-bit long long values are not truncated to double
+   // Get the value via TArrayL::At and store into a variable to be sure about the type. During direct comparison, a
+   // double return value may automatically promate Large to a double as well, introducing the truncation we want to
+   // test against.
+   const long long value = th1l->At(2);
+   EXPECT_EQ(value, Large);
 }
 
 TEST(ConvertToTH1L, RHist)

hist/histv7util/test/histutil_test.hxx

@@ -8,6 +8,7 @@
 #include <ROOT/RWeight.hxx>
 
 using namespace ROOT::Experimental::Hist;
+using ROOT::Experimental::RBinIndex;
 using ROOT::Experimental::RBinWithError;
 using ROOT::Experimental::RHist;
 using ROOT::Experimental::RHistEngine;