1. Тестирование. Mocking & stubbing.
   
2. Dependency inversion.

public interface Calculator {
    int add(int a, int b);
    
    static Calculator create() {
        return new Impl();
    }
    
    class Impl implements Calculator {
        @Override
        public int add(int a, int b) {
            return 0;
        }
    }
}

class node
{
  std::vector<std::shared_ptr<node>> childs;
};

  ... // код какого-то метода
  someObj.setField(SomeConfig.getInstance().getFieldValue())
  ... // код продолжается

_>  ... // код какого-то метода
_>  someObj.setField(SomeConfig.getInstance().getFieldValue())
_>  ... // код продолжается
_>

_>и все, пока в mockito не появился mockStatic никаких зубодробительных юнит-тестов не напишешь. а если это не java, то возможно вообще не напишешь

someObj.setField(ConfigHelper.getFieldValue())

AG>P.S. Подразумеваю C++ и наличие файлов *.h & *.cpp

class child;

class parent
{
  std::vector<std::shared_ptr<child>> childs;
};

BFE>class child;

BFE>class parent
BFE>{
BFE>  std::vector<std::shared_ptr<child>> childs;
BFE>};
BFE>

class INode // Интерфейс узла:
{
public:
    virtual std::string GetNameOfNode() const = 0;
    virtual std::vector<std::shared_ptr<INode>> GetVectOfChilds() const = 0;
    virtual void AddNode(std::shared_ptr<INode> p) = 0;
};

class Node : public INode // Класс реализации узла (header):
{
public:
    Node(const std::string& sNameOfNode); // C-tor
    ~Node(); // D-tor
    std::string GetNameOfNode() const override;
    std::vector<std::shared_ptr<INode>> GetVectOfChilds() const override;
    void AddNode(std::shared_ptr<INode> p) override;
};

if (text.ToUpper().Contains(...))
    doSomething();
else if (text.ToUpper().Contains(...))
    doSomethingElse();
else if (text.ToUpper().Contains(...))
    doSomethingDifferentElse();

AG>class INode // Интерфейс узла:
AG>{
AG>public:
AG>    virtual std::string GetNameOfNode() const = 0;
AG>    virtual std::vector<std::shared_ptr<INode>> GetVectOfChilds() const = 0;
AG>    virtual void AddNode(std::shared_ptr<INode> p) = 0;
AG>};
AG>

AG>class Node : public INode // Класс реализации узла (header):
AG>{
AG>public:
AG>    Node(const std::string& sNameOfNode); // C-tor
AG>    ~Node(); // D-tor
AG>    std::string GetNameOfNode() const override;
AG>    std::vector<std::shared_ptr<INode>> GetVectOfChilds() const override;
AG>    void AddNode(std::shared_ptr<INode> p) override;
AG>};
AG>

class SubNode;

class Node
{
public:
    Node(const std::string& sNameOfNode); // C-tor
   ~Node(); // D-tor
    std::string GetNameOfNode() const;
    const std::vector<SubNode>& GetVectOfChilds() const;
    void AddNode(SubNode p);
private:
    std::vector<SubNode> m_SubNodes;
};

class SubNode // Интерфейс узла:
{
public:
    std::string                 GetNameOfNode() const     {  return m_node->GetNameOfNode();  }
    const std::vector<SubNode>& GetVectOfChilds() const   {  return m_node->GetNameOfNode();  }
    void                        AddNode(SubNode node)     {  return m_node->AddNode(node);    }        
public:
    std::shared_ptr<Node> m_node;
};

class node
{
  std::vector<std::shared_ptr<node>> childs;
};

AG>Неудивительно, что это всё даже не компилируется

	Скрытый текст
	#include <iostream> #include <vector> #include <memory> #include <string> class Node; class SubNode // Интерфейс узла: { public: inline std::string GetNameOfNode() const ; inline const std::vector<SubNode>& GetVectOfChilds() const ; inline void AddNode(SubNode node) ; public: std::shared_ptr<Node> m_node; }; class Node { public: Node(const std::string& sNameOfNode); // C-tor ~Node(); // D-tor std::string GetNameOfNode() const; const std::vector<SubNode>& GetVectOfChilds() const; void AddNode(SubNode p); private: std::vector<SubNode> m_SubNodes; }; inline std::string SubNode::GetNameOfNode() const { return m_node->GetNameOfNode(); } inline const std::vector<SubNode>& SubNode::GetVectOfChilds() const { return m_node->GetVectOfChilds(); } inline void SubNode::AddNode(SubNode node) { return m_node->AddNode(node); } int main() { std::cout << "ok\n"; // your code goes here return 0; }

BFE>class Node
BFE>{
BFE>public:
BFE>    Node(const std::string& sNameOfNode); // C-tor
BFE>   ~Node(); // D-tor
BFE>    std::string GetNameOfNode() const;
BFE>    const std::vector<SubNode>& GetVectOfChilds() const;
BFE>    void AddNode(SubNode p);
BFE>private:
BFE>    std::vector<SubNode> m_SubNodes; // Здесь ссылаемся на объект типа SubNode
BFE>};

BFE>class SubNode // Интерфейс узла:
BFE>{
BFE>public:
BFE>    std::string                 GetNameOfNode() const     {  return m_node->GetNameOfNode();  }
BFE>    const std::vector<SubNode>& GetVectOfChilds() const   {  return m_node->GetNameOfNode();  }
BFE>    void                        AddNode(SubNode node)     {  return m_node->AddNode(node);    }        
BFE>public:
BFE>    std::shared_ptr<Node> m_node; // Здесь ссылаемся на объект типа Node
BFE>};
BFE>