OCCT

// Copyright (c) 2026 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#include <Aspect_GridParams.hxx>
#include <Precision.hxx>
#include <Quantity_Color.hxx>
#include <Standard_NegativeValue.hxx>
#include <gp_Pnt.hxx>

#include <gtest/gtest.h>

TEST(Aspect_GridParamsTest, Defaults_AreReasonable)
{
  Aspect_GridParams aParams;
  EXPECT_EQ(Quantity_NOC_GRAY70, aParams.Color().Name()) << "default color is grey";
  EXPECT_EQ(Quantity_NOC_GRAY50, aParams.AccentColor().Name())
    << "default accent color is darker grey";
  EXPECT_DOUBLE_EQ(0.01, aParams.Scale());
  EXPECT_DOUBLE_EQ(0.0, aParams.ScaleY()) << "default ScaleY is 0 (isotropic sentinel)";
  EXPECT_DOUBLE_EQ(0.01, aParams.EffectiveScaleY()) << "isotropic: EffectiveScaleY mirrors Scale";
  EXPECT_DOUBLE_EQ(0.0, aParams.AccentScaleX());
  EXPECT_DOUBLE_EQ(0.0, aParams.AccentScaleY());
  EXPECT_DOUBLE_EQ(0.0, aParams.AccentAngularScale());
  EXPECT_DOUBLE_EQ(0.01, aParams.LineThickness());
  EXPECT_DOUBLE_EQ(0.0, aParams.RotationAngle());
  EXPECT_EQ(0, aParams.AngularDivisions()) << "default grid is rectangular";
  EXPECT_FALSE(aParams.IsCircular());
  EXPECT_EQ(Aspect_GDM_Lines, aParams.DrawMode());
  EXPECT_FALSE(aParams.IsBackground());
  EXPECT_TRUE(aParams.IsDrawAxis());
  EXPECT_FALSE(aParams.IsViewAdaptive());
  EXPECT_NEAR(0.0, aParams.Origin().X(), Precision::Confusion());
  EXPECT_NEAR(0.0, aParams.Origin().Y(), Precision::Confusion());
  EXPECT_NEAR(0.0, aParams.Origin().Z(), Precision::Confusion());
  EXPECT_DOUBLE_EQ(0.0, aParams.SizeX());
  EXPECT_DOUBLE_EQ(0.0, aParams.SizeY());
  EXPECT_DOUBLE_EQ(0.0, aParams.Radius());
  EXPECT_DOUBLE_EQ(0.0, aParams.ZOffset());
  EXPECT_DOUBLE_EQ(0.0, aParams.AngleStart());
  EXPECT_DOUBLE_EQ(0.0, aParams.AngleEnd());
  EXPECT_FALSE(aParams.IsBounded());
  EXPECT_FALSE(aParams.IsArc());
}

TEST(Aspect_GridParamsTest, Bounds_RoundTrip)
{
  Aspect_GridParams aParams;
  EXPECT_FALSE(aParams.IsBounded());

  aParams.SetSizeX(10.0);
  EXPECT_DOUBLE_EQ(10.0, aParams.SizeX());
  EXPECT_TRUE(aParams.IsBounded());

  aParams.SetSizeX(0.0);
  EXPECT_FALSE(aParams.IsBounded())
    << "clearing SizeX returns to unbounded when other bounds are 0";

  aParams.SetSizeY(5.0);
  EXPECT_TRUE(aParams.IsBounded());
  aParams.SetSizeY(0.0);

  aParams.SetRadius(3.0);
  EXPECT_DOUBLE_EQ(3.0, aParams.Radius());
  EXPECT_TRUE(aParams.IsBounded());

  aParams.SetRadius(0.0);
  EXPECT_FALSE(aParams.IsBounded());

  aParams.SetZOffset(-0.01);
  EXPECT_DOUBLE_EQ(-0.01, aParams.ZOffset());
  EXPECT_FALSE(aParams.IsBounded()) << "ZOffset alone is not a bound";
}

TEST(Aspect_GridParamsTest, ArcRange_RoundTrip)
{
  Aspect_GridParams aParams;
  EXPECT_FALSE(aParams.IsArc());

  aParams.SetArcRange(0.0, M_PI);
  EXPECT_DOUBLE_EQ(0.0, aParams.AngleStart());
  EXPECT_DOUBLE_EQ(M_PI, aParams.AngleEnd());
  EXPECT_TRUE(aParams.IsArc());

  // Equal start and end reverts to full circle sentinel.
  aParams.SetArcRange(1.0, 1.0);
  EXPECT_FALSE(aParams.IsArc());

  // Wraparound: Start > End is allowed; renderer walks CCW through the wrap.
  aParams.SetArcRange(2.356, -2.356);
  EXPECT_TRUE(aParams.IsArc());
}

TEST(Aspect_GridParamsTest, DrawMode_RoundTrip)
{
  Aspect_GridParams aParams;
  aParams.SetDrawMode(Aspect_GDM_Points);
  EXPECT_EQ(Aspect_GDM_Points, aParams.DrawMode());
  aParams.SetDrawMode(Aspect_GDM_None);
  EXPECT_EQ(Aspect_GDM_None, aParams.DrawMode());
  aParams.SetDrawMode(Aspect_GDM_Lines);
  EXPECT_EQ(Aspect_GDM_Lines, aParams.DrawMode());
}

TEST(Aspect_GridParamsTest, AngularDivisions_ToggleCircular)
{
  Aspect_GridParams aParams;
  EXPECT_FALSE(aParams.IsCircular());

  aParams.SetAngularDivisions(8);
  EXPECT_EQ(8, aParams.AngularDivisions());
  EXPECT_TRUE(aParams.IsCircular());

  aParams.SetAngularDivisions(0);
  EXPECT_FALSE(aParams.IsCircular()) << "zero divisions falls back to rectangular";
}

TEST(Aspect_GridParamsTest, EffectiveScaleY_FollowsScaleWhenZero)
{
  Aspect_GridParams aParams;
  aParams.SetScale(0.25);
  EXPECT_DOUBLE_EQ(0.25, aParams.EffectiveScaleY());
  aParams.SetScaleY(0.5);
  EXPECT_DOUBLE_EQ(0.5, aParams.EffectiveScaleY());
  aParams.SetScaleY(0.0);
  EXPECT_DOUBLE_EQ(0.25, aParams.EffectiveScaleY()) << "clearing ScaleY restores isotropy";
}

TEST(Aspect_GridParamsTest, RotationAngle_RoundTrip)
{
  Aspect_GridParams aParams;
  aParams.SetRotationAngle(0.5);
  EXPECT_DOUBLE_EQ(0.5, aParams.RotationAngle());
  aParams.SetRotationAngle(-1.25);
  EXPECT_DOUBLE_EQ(-1.25, aParams.RotationAngle());
}

TEST(Aspect_GridParamsTest, Setters_RoundTrip)
{
  Aspect_GridParams aParams;

  const Quantity_Color aBlue(Quantity_NOC_BLUE1);
  aParams.SetColor(aBlue);
  EXPECT_EQ(aBlue, aParams.Color());

  const Quantity_Color aRed(Quantity_NOC_RED);
  aParams.SetAccentColor(aRed);
  EXPECT_EQ(aRed, aParams.AccentColor());

  const gp_Pnt aOrigin(1.0, 2.0, 3.0);
  aParams.SetOrigin(aOrigin);
  EXPECT_NEAR(1.0, aParams.Origin().X(), Precision::Confusion());
  EXPECT_NEAR(2.0, aParams.Origin().Y(), Precision::Confusion());
  EXPECT_NEAR(3.0, aParams.Origin().Z(), Precision::Confusion());

  aParams.SetScale(0.5);
  EXPECT_DOUBLE_EQ(0.5, aParams.Scale());

  aParams.SetScaleY(0.75);
  EXPECT_DOUBLE_EQ(0.75, aParams.ScaleY());
  EXPECT_DOUBLE_EQ(0.75, aParams.EffectiveScaleY());

  aParams.SetAccentScaleX(0.05);
  aParams.SetAccentScaleY(0.1);
  aParams.SetAccentAngularScale(2.5);
  EXPECT_DOUBLE_EQ(0.05, aParams.AccentScaleX());
  EXPECT_DOUBLE_EQ(0.1, aParams.AccentScaleY());
  EXPECT_DOUBLE_EQ(2.5, aParams.AccentAngularScale());

  aParams.SetLineThickness(0.02);
  EXPECT_DOUBLE_EQ(0.02, aParams.LineThickness());

  aParams.SetRotationAngle(0.123);
  EXPECT_DOUBLE_EQ(0.123, aParams.RotationAngle());

  aParams.SetAngularDivisions(12);
  EXPECT_EQ(12, aParams.AngularDivisions());
  EXPECT_TRUE(aParams.IsCircular());

  aParams.SetIsBackground(true);
  EXPECT_TRUE(aParams.IsBackground());

  aParams.SetIsDrawAxis(false);
  EXPECT_FALSE(aParams.IsDrawAxis());

  aParams.SetIsViewAdaptive(true);
  EXPECT_TRUE(aParams.IsViewAdaptive());
}

TEST(Aspect_GridParamsTest, Copy_PreservesFields)
{
  Aspect_GridParams aSrc;
  aSrc.SetColor(Quantity_Color(0.1, 0.2, 0.3, Quantity_TOC_RGB));
  aSrc.SetOrigin(gp_Pnt(4.0, 5.0, 6.0));
  aSrc.SetAccentColor(Quantity_Color(0.7, 0.6, 0.5, Quantity_TOC_RGB));
  aSrc.SetScale(0.25);
  aSrc.SetScaleY(0.125);
  aSrc.SetAccentScaleX(0.025);
  aSrc.SetAccentScaleY(0.0125);
  aSrc.SetAccentAngularScale(3.0);
  aSrc.SetLineThickness(0.04);
  aSrc.SetRotationAngle(-0.5);
  aSrc.SetAngularDivisions(16);
  aSrc.SetIsBackground(true);
  aSrc.SetIsDrawAxis(false);
  aSrc.SetIsViewAdaptive(true);
  aSrc.SetSizeX(7.0);
  aSrc.SetSizeY(3.0);
  aSrc.SetRadius(2.0);
  aSrc.SetZOffset(-0.002);
  aSrc.SetArcRange(0.25, 2.0);

  const Aspect_GridParams aCopy = aSrc;
  EXPECT_NEAR(0.1, aCopy.Color().Red(), Precision::Confusion());
  EXPECT_NEAR(0.2, aCopy.Color().Green(), Precision::Confusion());
  EXPECT_NEAR(0.3, aCopy.Color().Blue(), Precision::Confusion());
  EXPECT_NEAR(4.0, aCopy.Origin().X(), Precision::Confusion());
  EXPECT_NEAR(5.0, aCopy.Origin().Y(), Precision::Confusion());
  EXPECT_NEAR(6.0, aCopy.Origin().Z(), Precision::Confusion());
  EXPECT_NEAR(0.7, aCopy.AccentColor().Red(), Precision::Confusion());
  EXPECT_NEAR(0.6, aCopy.AccentColor().Green(), Precision::Confusion());
  EXPECT_NEAR(0.5, aCopy.AccentColor().Blue(), Precision::Confusion());
  EXPECT_DOUBLE_EQ(0.25, aCopy.Scale());
  EXPECT_DOUBLE_EQ(0.125, aCopy.ScaleY());
  EXPECT_DOUBLE_EQ(0.125, aCopy.EffectiveScaleY());
  EXPECT_DOUBLE_EQ(0.025, aCopy.AccentScaleX());
  EXPECT_DOUBLE_EQ(0.0125, aCopy.AccentScaleY());
  EXPECT_DOUBLE_EQ(3.0, aCopy.AccentAngularScale());
  EXPECT_DOUBLE_EQ(0.04, aCopy.LineThickness());
  EXPECT_DOUBLE_EQ(-0.5, aCopy.RotationAngle());
  EXPECT_EQ(16, aCopy.AngularDivisions());
  EXPECT_TRUE(aCopy.IsCircular());
  EXPECT_TRUE(aCopy.IsBackground());
  EXPECT_FALSE(aCopy.IsDrawAxis());
  EXPECT_TRUE(aCopy.IsViewAdaptive());
  EXPECT_DOUBLE_EQ(7.0, aCopy.SizeX());
  EXPECT_DOUBLE_EQ(3.0, aCopy.SizeY());
  EXPECT_DOUBLE_EQ(2.0, aCopy.Radius());
  EXPECT_DOUBLE_EQ(-0.002, aCopy.ZOffset());
  EXPECT_DOUBLE_EQ(0.25, aCopy.AngleStart());
  EXPECT_DOUBLE_EQ(2.0, aCopy.AngleEnd());
  EXPECT_TRUE(aCopy.IsBounded());
  EXPECT_TRUE(aCopy.IsArc());
}

#ifndef No_Exception
TEST(Aspect_GridParamsTest, Setters_RejectNegativeValues)
{
  Aspect_GridParams aParams;
  EXPECT_THROW(aParams.SetScale(-1.0), Standard_NegativeValue);
  EXPECT_THROW(aParams.SetScaleY(-1.0), Standard_NegativeValue);
  EXPECT_THROW(aParams.SetLineThickness(-0.1), Standard_NegativeValue);
  EXPECT_THROW(aParams.SetSizeX(-1.0), Standard_NegativeValue);
  EXPECT_THROW(aParams.SetSizeY(-1.0), Standard_NegativeValue);
  EXPECT_THROW(aParams.SetRadius(-1.0), Standard_NegativeValue);
}
#endif