using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using System.Text;

​

public class Solution 

{

    public TreeNode RemoveLeafNodes(TreeNode root, int target) 

    {

        if (root == null)

            return null;

        if (root.val == target && root.left == null && root.right == null)

            return null;

        root.left = RemoveLeafNodes(root.left, target);

        root.right = RemoveLeafNodes(root.right, target);

        if (root.val == target && root.left == null && root.right == null)

            return null;

        return root;

    }

}

​

public class TreeNode 

{

    public int val;

    public TreeNode left;

    public TreeNode right;

    public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) 

    {

        this.val = val;

        this.left = left;

        this.right = right;

    }

    public override string ToString()

    {

        return Serialize(this);

    }

    public static string Serialize(TreeNode root)

    {

        if (root == null)

            return "null";

        var sb = new StringBuilder();

        sb.Append("[");

        var queue = new Queue<TreeNode>();

        queue.Enqueue(root);

        while (queue.Count != 0)

        {

            var node = queue.Dequeue();

            if (node != null)

            {

                sb.Append(node.val.ToString() + ",");

                queue.Enqueue(node.left);

                queue.Enqueue(node.right);

            }

            else

            {

                sb.Append("null,");

            }

        }

        if (sb[sb.Length - 1] == ',')

        {

            sb.Remove(sb.Length - 1, 1);

        }

        sb.Append("]");

        return sb.ToString();

    }

    public static TreeNode Deserialize(string treeString)

    {

        if (string.IsNullOrEmpty(treeString))

            return null;

        treeString = treeString.Trim(new [] {'[', ']'});

        if (string.IsNullOrEmpty(treeString))

            return null;

        var vals = new Queue<string>(treeString.Split(','));

        if (vals.Count == 0 || vals.Peek() == "null")

            return null;

        var queue = new Queue<TreeNode>();

        var root = new TreeNode(int.Parse(vals.Dequeue()));

        queue.Enqueue(root);

        while (queue.Count != 0 && vals.Count > 1)

        {

            var node = queue.Dequeue();

            var left = vals.Dequeue();

            var right = vals.Dequeue();

            if (left != "null")

            {

                node.left = new TreeNode(int.Parse(left));

                queue.Enqueue(node.left);

            }

            if (right != "null")

            {

                node.right = new TreeNode(int.Parse(right));

                queue.Enqueue(node.right);

            }

        }

        return root;

    }

}

​

public static class TreeNodeExtensions

{

    public static string Serialize(this TreeNode root)

    {

        return TreeNode.Serialize(root);

    }

    public static TreeNode DeserializeTreeNode(this string treeString)

    {

        return TreeNode.Deserialize(treeString);

    }

}

public class Program

{

    public static void Main()

    {

        var solution = new Solution();

        Case.SetResultGenerator(((TreeNode root, int target) input) => solution.RemoveLeafNodes(input.root, input.target));

        Case.SetResultChecker<(TreeNode root, int target), TreeNode>((r,e) => r.Serialize() == e.Serialize());

        Case

            .CreateCase(

                (TreeNode.Deserialize("[1,2,3,2,null,2,4]"), 2),

                TreeNode.Deserialize("[1,null,3,null,4]"))

            .Run()

            .PrintResult();

        Case

            .CreateCase(

                (TreeNode.Deserialize("[1,3,3,3,2]"), 3),

                TreeNode.Deserialize("[1,3,null,null,2]"))

            .Run()

            .PrintResult();

        Case

            .CreateCase(

                (TreeNode.Deserialize("[1,2,null,2,null,2]"), 2),

                TreeNode.Deserialize("[1]"))

            .Run()

            .PrintResult();

    }

}

​

public static class Extensions

{

    public static void Print(this object obj)

    {

        Console.WriteLine(obj.TryGetObjectString());

    }

    public static string TryGetObjectString(this object input)

    {

        if (input is not IEnumerable someEnumerable || input is string)

        {

            if (!(input.GetType().Name.Contains(nameof(ValueTuple))))

                return input.ToString();

            someEnumerable = input.GetType().GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public).Select(x => x.GetValue(input)) as IEnumerable;

        }

        var result = "[";

        var first = true;

        foreach (var item in someEnumerable)

        {

            if (first)

            {

                first = false;

            }

            else

            {

                result += ", ";

            }

            result += TryGetObjectString(item);

        }

        result += "]";

        return result;

    }

    public static T[] SubArray<T>(this T[] data, int index, int length)

    {

        T[] result = new T[length];

        Array.Copy(data, index, result, 0, length);

        return result;

    }

}

​

public class Case

{

    public static Case<TInput, TResult> CreateCase<TInput, TResult>(TInput input, TResult expectedResult)

    {

        return new Case<TInput, TResult>(input, expectedResult);

    }

    public static void SetResultGenerator(Delegate @delegate)

    {

        var returnType = @delegate.Method.ReturnType;

        if (returnType == typeof(void))

            throw new InvalidOperationException("Delegate with return type 'void' is not supported.");

        var parameters = @delegate.Method.GetParameters();

        if (parameters.Count() != 1)

            throw new InvalidOperationException("Only one input parameter can be handeled. Use a tuple and an anonymous func if you need more than one.");

        var inputType = parameters.First().ParameterType;

        var setResultGeneratorMethod = 

            typeof(Case)

                .GetMethods(BindingFlags.Public | BindingFlags.Static)

                .First(m => m.IsGenericMethod && m.Name == nameof(Case.SetResultGenerator));

        var genericSetResultGeneratorMethod = setResultGeneratorMethod.MakeGenericMethod(inputType, returnType);

        var convertedDelegate = 

            typeof(Case)

                .GetMethod(nameof(CastResultGenerator), BindingFlags.NonPublic | BindingFlags.Static)

                .MakeGenericMethod(inputType, returnType)

                .Invoke(null, new object[] { @delegate });

        genericSetResultGeneratorMethod.Invoke(null, new object[] { convertedDelegate });

    }

    public static void SetResultGenerator<TInput, TResult>(Func<TInput, TResult> resultGenerator)

    {

        Case<TInput, TResult>.ResultGenerator = resultGenerator;

    }

    public static void SetResultChecker<TInput, TResult>(Func<TResult, TResult, bool> resultChecker)

    {

        Case<TInput, TResult>.ResultChecker = resultChecker;

    }

    private static Func<TInput, TResult> CastResultGenerator<TInput, TResult>(Delegate @delegate)

    {

        var castedDelegate = (Func<TInput, TResult>)@delegate;

        return castedDelegate;

    }

    private static Func<TInput, TResult, bool> CastResultChecker<TInput, TResult>(Delegate @delegate)

    {

        var castedDelegate = (Func<TInput, TResult, bool>)@delegate;

        return castedDelegate;

    }

}

​

public class Case<TInput, TResult>

{

    public static Func<TInput, TResult> ResultGenerator { get; set; }

    public static Func<TResult, TResult, bool> ResultChecker { get; set; }

​

    public TInput Input { get; set; }

    public TResult ExpectedResult { get; set; }

    public TResult ActualResult { get; set; }

    public bool Passed { get; set; }

    static Case()

    {

        Case.SetResultChecker<TInput, TResult>((a, e) => a.Equals(e));

    }

    public Case(TInput input, TResult expectedResult)

    {

        Input = input;

        ExpectedResult = expectedResult;

    }

    public Case<TInput, TResult> GenerateResult()

    {

        ActualResult = ResultGenerator(Input);

        return this;

    }

    public bool ResultAsExpected()

    {

        return ResultChecker(ActualResult, ExpectedResult);

    }

    public Case<TInput, TResult> Run()

    {

        GenerateResult();

        Passed = ResultAsExpected();

        return this;

    }

    public Case<TInput, TResult> PrintResult()

    {

        $"Test {(Passed ? "passed" : "failed" )}.".Print();

        $"Input: {Input.TryGetObjectString()}".Print();

        $"Result: {ActualResult.TryGetObjectString()}".Print();

        $"Expected: {ExpectedResult.TryGetObjectString()}".Print();

        string.Empty.Print();

        return this;

    }

}