public void Parent_OnChangedParent_Passes()
{
{
var callbacks = new SmartDelegate <Callback>();
var c = 0;
callbacks.Add((_) => c++);
callbacks.Add((_) => { });
callbacks.SafeDynamicInvoke(0, () => "test fail...");
}
var node = new TreeNodeHelper <int>();
int callCounter = 0;
(TreeNodeHelper <int> self, TreeNodeHelper <int> parent, TreeNodeHelper <int> prevParent)recievedValue = default;
node.OnChangedParent.Add((_s, _p, _prev) => {
callCounter++;
recievedValue = (_s, _p, _prev);
});
node.OnChangedParent.Add((_, __, ___) => throw new System.Exception());
var parent = node.CreateNode(100);
Assert.DoesNotThrow(() => {
node.Parent = parent;
});
Assert.AreEqual(1, callCounter);
Assert.AreSame(node, recievedValue.self);
Assert.AreSame(parent, recievedValue.parent);
Assert.IsNull(recievedValue.prevParent);
}
public void SafeDynamicInvoke_Arg3Passes()
{
{
var d = new SmartDelegate <SafeDynamicInvokeDelegateArg3>();
int callCounter = 0;
(int, int, int)recievedValue = default;
d.Add((_n, _m, _l) => { callCounter++; recievedValue = (_n, _m, _l); });
var value1 = 100;
var value2 = 200;
var value3 = 300;
d.SafeDynamicInvoke(value1, value2, value3, () => "ErrorLog");
Assert.AreEqual(1, callCounter);
Assert.AreEqual(value1, recievedValue.Item1);
Assert.AreEqual(value2, recievedValue.Item2);
Assert.AreEqual(value3, recievedValue.Item3);
}
{
var d = new SmartDelegate <SafeDynamicInvokeDelegateArg3>();
d.Add((_n, _m, _l) => { throw new System.Exception(); });
Assert.DoesNotThrow(() =>
d.SafeDynamicInvoke(100, () => "ErrorLog")
);
}
{
var d = new SmartDelegate <SafeDynamicInvokeDelegateArg3>();
Assert.DoesNotThrow(() =>
d.SafeDynamicInvoke(() => "ErrorLog")
);
Debug.Log($"Success to Empty Delegate");
}
}
public void SafeDynamicInvoke_Arg1Passes()
{
{
var d = new SmartDelegate <SafeDynamicInvokeDelegateArg1>();
int callCounter = 0;
int recievedValue = 0;
d.Add((_n) => { callCounter++; recievedValue = _n; });
var value = 100;
d.SafeDynamicInvoke(value, () => "ErrorLog");
Assert.AreEqual(1, callCounter);
Assert.AreEqual(value, recievedValue);
}
{
var d = new SmartDelegate <SafeDynamicInvokeDelegateArg1>();
d.Add((_n) => { throw new System.Exception(); });
Assert.DoesNotThrow(() =>
d.SafeDynamicInvoke(100, () => "ErrorLog")
);
}
{
var d = new SmartDelegate <SafeDynamicInvokeDelegateArg1>();
Assert.DoesNotThrow(() =>
d.SafeDynamicInvoke(() => "ErrorLog")
);
Debug.Log($"Success to Empty Delegate");
}
}
public void SafeDynamicInvoke_NoneArgPasses()
{
{
var d = new SmartDelegate <SafeDynamicInvokeDelegate>();
int callCounter = 0;
d.Add(() => callCounter++);
d.SafeDynamicInvoke(() => "ErrorLog");
Assert.AreEqual(1, callCounter);
}
{
var d = new SmartDelegate <SafeDynamicInvokeDelegate>();
d.Add(() => { throw new System.Exception(); });
Assert.DoesNotThrow(() =>
d.SafeDynamicInvoke(() => "ErrorLog")
);
}
{
var d = new SmartDelegate <SafeDynamicInvokeDelegate>();
Assert.DoesNotThrow(() =>
d.SafeDynamicInvoke(() => "ErrorLog")
);
Debug.Log($"Success to Empty Delegate");
}
}
public void RegistedDelegateCountPasses()
{
var d = new SmartDelegate <BasicUsagePassesDelegate>();
d.Add(() => { });
d.Add(Apple);
Assert.AreEqual(2, d.RegistedDelegateCount);
d.Remove(Apple);
Assert.AreEqual(1, d.RegistedDelegateCount);
}
public void SafeDynamicInvoke_CallCallback_Passes()
{
var d = new SmartDelegate <CallCallbackDelegate>();
var callCounter = 0;
d.Add(() => callCounter++);
d.Add(() => throw new System.Exception());
var returnValues = d.SafeDynamicInvoke(() => "");
Assert.AreEqual(1, callCounter);
}
public void Add_Dumplication_Passes()
{
var predicate = new SmartDelegate <BasicUsagePassesDelegate>();
Assert.IsFalse(predicate.IsValid);
Assert.IsNull(predicate.Instance);
//test point
BasicUsagePassesDelegate incrementFunc = () => {; };
predicate.Add(incrementFunc);
predicate.Add(incrementFunc);
Assert.IsTrue(predicate.IsValid);
Assert.IsNotNull(predicate.Instance);
Assert.AreEqual(1, predicate.RegistedDelegateCount);
}
public void SafeDynamicInvoke_ReturnValues_Passes()
{
var d = new SmartDelegate <ReturnValueDelegate>();
d.Add(() => 10);
d.Add(() => 20);
d.Add(() => 30);
var returnValues = d.SafeDynamicInvoke(() => "");
var t = returnValues.Select(_n => _n.ToString()).Aggregate("", (_s, _c) => _s + _c + ", ");
Debug.Log($"test -- {t}");
AssertionUtils.AssertEnumerable(
new object[] {
10, 20, 30
}
, returnValues
, ""
);
}
public void Contains_Passes()
{
var predicate = new SmartDelegate <BasicUsagePassesDelegate>();
Assert.IsFalse(predicate.IsValid);
Assert.IsNull(predicate.Instance);
//test point
BasicUsagePassesDelegate incrementFunc = () => {; };
Assert.IsFalse(predicate.Contains(incrementFunc));
predicate.Add(incrementFunc);
Assert.IsTrue(predicate.Contains(incrementFunc));
var copy = incrementFunc;
Assert.IsTrue(predicate.Contains(copy));
predicate.Remove(incrementFunc);
Assert.IsFalse(predicate.Contains(incrementFunc));
}
public void BasicUsagePasses()
{
var predicate = new SmartDelegate <BasicUsagePassesDelegate>();
Assert.IsFalse(predicate.IsValid);
Assert.IsNull(predicate.Instance);
int count = 0;
BasicUsagePassesDelegate incrementFunc = () => { count++; };
predicate.Set(incrementFunc);
Assert.IsTrue(predicate.IsValid);
Assert.IsNotNull(predicate.Instance);
predicate.Instance.Invoke();
Assert.AreEqual(1, count);
predicate.Remove(incrementFunc);
Assert.IsFalse(predicate.IsValid);
Assert.IsNull(predicate.Instance);
predicate.Add(incrementFunc);
Assert.IsTrue(predicate.IsValid);
Assert.IsNotNull(predicate.Instance);
var predicate2 = new SmartDelegate <BasicUsagePassesDelegate>(predicate);
Assert.IsTrue(predicate2.IsValid);
Assert.IsNotNull(predicate2.Instance);
count = 0;
predicate2.Instance.Invoke();
Assert.AreEqual(1, count);
predicate.Clear();
Assert.IsFalse(predicate.IsValid);
Assert.IsNull(predicate.Instance);
}
